rubocop 0.35.1 → 0.36.0

data/lib/rubocop/ast_node/builder.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module RuboCop
+  class Node
+    # `RuboCop::Builder` is an AST builder that is utilized to let `Parser`
+    # generate ASTs with {RuboCop::Node}.
+    #
+    # @example
+    #   buffer = Parser::Source::Buffer.new('(string)')
+    #   buffer.source = 'puts :foo'
+    #
+    #   builder = RuboCop::Builder.new
+    #   parser = Parser::CurrentRuby.new(builder)
+    #   root_node = parser.parse(buffer)
+    class Builder < Parser::Builders::Default
+      # Generates {Node} from the given information.
+      #
+      # @return [Node] the generated node
+      def n(type, children, source_map)
+        Node.new(type, children, location: source_map)
+      end
+    end
+  end
+end

data/lib/rubocop/ast_node/sexp.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module RuboCop
+  # This module provides a shorthand method to create a {Node} like `AST::Sexp`.
+  #
+  # @see http://rubydoc.info/gems/ast/AST/Sexp
+  module Sexp
+    # Creates a {Node} with type `type` and children `children`.
+    def s(type, *children)
+      Node.new(type, children)
+    end
+  end
+end

data/lib/rubocop/cached_data.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'json'
+
+module RuboCop
+  # Converts RuboCop objects to and from the serialization format JSON.
+  class CachedData
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def from_json(text)
+      deserialize_offenses(JSON.load(text))
+    end
+
+    def to_json(offenses)
+      JSON.dump(offenses.map { |o| serialize_offense(o) })
+    end
+
+    private
+
+    def serialize_offense(offense)
+      # JSON.dump will fail if the offense message contains text which is not
+      # valid UTF-8
+      message = offense.message
+      message = if message.respond_to?(:scrub)
+                  message.scrub
+                else
+                  message.chars.select(&:valid_encoding?).join
+                end
+
+      {
+        severity: offense.severity,
+        location: {
+          begin_pos: offense.location.begin_pos,
+          end_pos: offense.location.end_pos
+        },
+        message:  message,
+        cop_name: offense.cop_name,
+        status:   offense.status
+      }
+    end
+
+    # Restore an offense object loaded from a JSON file.
+    def deserialize_offenses(offenses)
+      source_buffer = Parser::Source::Buffer.new(@filename)
+      source_buffer.read
+      offenses.map! do |o|
+        location = Parser::Source::Range.new(source_buffer,
+                                             o['location']['begin_pos'],
+                                             o['location']['end_pos'])
+        Cop::Offense.new(o['severity'], location, o['message'], o['cop_name'],
+                         o['status'].to_sym)
+      end
+    end
+  end
+end

data/lib/rubocop/cli.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   # The CLI is a class responsible of handling all the command line interface
@@ -6,6 +7,8 @@ module RuboCop
   class CLI
     include Formatter::TextUtil
 
+    class Finished < Exception; end
+
     attr_reader :options, :config_store
 
     def initialize
@@ -20,22 +23,25 @@ module RuboCop
     def run(args = ARGV)
       @options, paths = Options.new.parse(args)
       act_on_options
+      apply_default_formatter
 
       runner = Runner.new(@options, @config_store)
       trap_interrupt(runner)
       all_passed = runner.run(paths)
       display_warning_summary(runner.warnings)
       display_error_summary(runner.errors)
+      maybe_print_corrected_source
 
       all_passed && !runner.aborting? && runner.errors.empty? ? 0 : 1
-    rescue Cop::AmbiguousCopName => e
-      $stderr.puts "Ambiguous cop name #{e.message} needs namespace " \
-                   'qualifier.'
-      return 1
+    rescue RuboCop::Error => e
+      $stderr.puts Rainbow("Error: #{e.message}").red
+      return 2
+    rescue Finished
+      return 0
     rescue StandardError, SyntaxError => e
       $stderr.puts e.message
       $stderr.puts e.backtrace
-      return 1
+      return 2
     end
 
     def trap_interrupt(runner)
@@ -54,11 +60,16 @@ module RuboCop
 
       ConfigLoader.debug = @options[:debug]
       ConfigLoader.auto_gen_config = @options[:auto_gen_config]
-      ConfigLoader.exclude_limit = @options[:exclude_limit]
 
       @config_store.options_config = @options[:config] if @options[:config]
 
-      Rainbow.enabled = false unless @options[:color]
+      if @options[:color]
+        # color output explicitly forced on
+        Rainbow.enabled = true
+      elsif @options[:color] == false
+        # color output explicitly forced off
+        Rainbow.enabled = false
+      end
     end
 
     def handle_exiting_options
@@ -67,7 +78,22 @@ module RuboCop
       puts RuboCop::Version.version(false) if @options[:version]
       puts RuboCop::Version.version(true) if @options[:verbose_version]
       print_available_cops if @options[:show_cops]
-      exit(0)
+      fail Finished
+    end
+
+    def apply_default_formatter
+      # This must be done after the options have already been processed,
+      # because they can affect how ConfigStore behaves
+      @options[:formatters] ||= begin
+        cfg = @config_store.for(Dir.pwd)['AllCops']
+        formatter = (cfg && cfg['DefaultFormatter']) || 'progress'
+        [[formatter, @options[:output_path]]]
+      end
+
+      if @options[:auto_gen_config]
+        @options[:formatters] << [Formatter::DisabledConfigFormatter,
+                                  ConfigLoader::AUTO_GENERATED_FILE]
+      end
     end
 
     def print_available_cops
@@ -95,8 +121,8 @@ module RuboCop
       selected_cops.each do |cop|
         puts '# Supports --auto-correct' if cop.new.support_autocorrect?
         puts "#{cop.cop_name}:"
-        cnf = @config_store.for(Dir.pwd.to_s).for_cop(cop)
-        puts cnf.to_yaml.lines.to_a[1..-1].map { |line| '  ' + line }
+        cnf = @config_store.for(Dir.pwd).for_cop(cop)
+        puts cnf.to_yaml.lines.to_a.butfirst.map { |line| '  ' + line }
         puts
       end
     end
@@ -123,5 +149,16 @@ module RuboCop
         #{RuboCop::Version.version(true)}
       END
     end
+
+    def maybe_print_corrected_source
+      # If we are asked to autocorrect source code read from stdin, the only
+      # reasonable place to write it is to stdout
+      # Unfortunately, we also write other information to stdout
+      # So a delimiter is needed for tools to easily identify where the
+      # autocorrected source begins
+      return unless @options[:stdin] && @options[:auto_correct]
+      puts '=' * 20
+      print @options[:stdin]
+    end
   end
 end

data/lib/rubocop/comment_config.rb

@@ -1,10 +1,11 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   # This class parses the special `rubocop:disable` comments in a source
   # and provides a way to check if each cop is enabled at arbitrary line.
   class CommentConfig
-    UNNEEDED_DISABLE = 'Lint/UnneededDisable'
+    UNNEEDED_DISABLE = 'Lint/UnneededDisable'.freeze
     COMMENT_DIRECTIVE_REGEXP = Regexp.new(
       '\A# rubocop : ((?:dis|en)able)\b ((?:[\w/]+,? )+)'.gsub(' ', '\s*')
     )
@@ -35,6 +36,12 @@ module RuboCop
         if single_line
           disabled_line_ranges[cop_name] << (line..line) if disabled
         elsif disabled
+          if disablement_start_line_numbers[cop_name]
+            # Cop already disabled on this line, so we end the current disabled
+            # range before we start a new range.
+            start_line = disablement_start_line_numbers.delete(cop_name)
+            disabled_line_ranges[cop_name] << (start_line..line)
+          end
           disablement_start_line_numbers[cop_name] = line
         else
           start_line = disablement_start_line_numbers.delete(cop_name)
@@ -66,7 +73,7 @@ module RuboCop
         single_line = !comment_only_line?(comment_line_number)
 
         cop_names.each do |cop_name|
-          cop_name = Cop::Cop.qualified_cop_name(cop_name,
+          cop_name = Cop::Cop.qualified_cop_name(cop_name.strip,
                                                  processed_source.buffer.name)
           yield cop_name, disabled, comment_line_number, single_line
         end

data/lib/rubocop/config.rb

@@ -1,20 +1,22 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
-require 'delegate'
 require 'pathname'
 
+# rubocop:disable Metrics/ClassLength
+
 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 Config < Hash
     include PathUtil
 
-    class ValidationError < StandardError; end
-
-    COMMON_PARAMS = %w(Exclude Include Severity AutoCorrect StyleGuide Details)
+    COMMON_PARAMS = %w(Exclude Include Severity
+                       AutoCorrect StyleGuide Details).freeze
+    KNOWN_RUBIES = [1.9, 2.0, 2.1, 2.2, 2.3].freeze
 
     attr_reader :loaded_path
 
@@ -23,15 +25,11 @@ module RuboCop
       @for_cop = Hash.new do |h, cop|
         h[cop] = self[Cop::Cop.qualified_cop_name(cop, loaded_path)] || {}
       end
-      super(hash)
-    end
-
-    def to_s
-      @to_s ||= __getobj__.to_s
+      replace(hash)
     end
 
     def make_excludes_absolute
-      keys.each do |key|
+      each_key do |key|
         validate_section_presence(key)
         next unless self[key]['Exclude']
 
@@ -61,8 +59,7 @@ module RuboCop
     end
 
     def deprecation_check
-      all_cops = self['AllCops']
-      return unless all_cops
+      return unless (all_cops = self['AllCops'])
 
       %w(Exclude Include).each do |key|
         plural = "#{key}s"
@@ -79,13 +76,17 @@ module RuboCop
     end
 
     def cop_enabled?(cop)
-      for_cop(cop).empty? || for_cop(cop)['Enabled']
-    end
+      department = if cop.respond_to?(:cop_type)
+                     cop.cop_type.to_s.capitalize
+                   else
+                     cop.split('/')[-2]
+                   end
+
+      if (dept_config = self[department])
+        return false if dept_config['Enabled'] == false
+      end
 
-    def warn_unless_valid
-      validate
-    rescue Config::ValidationError => e
-      warn Rainbow.new.wrap("Warning: #{e.message}").red
+      for_cop(cop).empty? || for_cop(cop)['Enabled']
     end
 
     def add_missing_namespaces
@@ -98,7 +99,6 @@ module RuboCop
       end
     end
 
-    # TODO: This should be a private method
     def validate
       # Don't validate RuboCop's own files. Avoids infinite recursion.
       base_config_path = File.expand_path(File.join(ConfigLoader::RUBOCOP_HOME,
@@ -109,11 +109,12 @@ module RuboCop
         ConfigLoader.default_configuration.key?(key)
       end
 
-      invalid_cop_names.each do |name|
-        fail ValidationError, "unrecognized cop #{name} found in #{loaded_path}"
-      end
-
+      reject_obsolete_cops
+      warn_about_unrecognized_cops(invalid_cop_names)
+      reject_obsolete_parameters
+      check_target_ruby
       validate_parameter_names(valid_cop_names)
+      validate_enforced_styles(valid_cop_names)
     end
 
     def file_to_include?(file)
@@ -136,12 +137,9 @@ module RuboCop
     # Returns true if there's a chance that an Include pattern matches hidden
     # files, false if that's definitely not possible.
     def possibly_include_hidden?
-      if @possibly_include_hidden.nil?
-        @possibly_include_hidden = patterns_to_include.any? do |s|
-          s.is_a?(Regexp) || s.start_with?('.') || s.include?('/.')
-        end
+      @possibly_include_hidden ||= patterns_to_include.any? do |s|
+        s.is_a?(Regexp) || s.start_with?('.') || s.include?('/.')
       end
-      @possibly_include_hidden
     end
 
     def file_to_exclude?(file)
@@ -181,6 +179,22 @@ module RuboCop
 
     private
 
+    def warn_about_unrecognized_cops(invalid_cop_names)
+      invalid_cop_names.each do |name|
+        if name == 'Syntax'
+          fail ValidationError,
+               "configuration for Syntax cop found in #{loaded_path}\n" \
+               'This cop cannot be configured.'
+        end
+
+        # There could be a custom cop with this name. If so, don't warn
+        next if Cop::Cop.all.any? { |c| c.match?([name]) }
+
+        warn Rainbow("Warning: unrecognized cop #{name} found in " \
+                     "#{loaded_path}").yellow
+      end
+    end
+
     def validate_section_presence(name)
       return unless key?(name) && self[name].nil?
       fail ValidationError, "empty section #{name} found in #{loaded_path}"
@@ -193,10 +207,64 @@ module RuboCop
           next if COMMON_PARAMS.include?(param) ||
                   ConfigLoader.default_configuration[name].key?(param)
 
-          fail ValidationError,
-               "unrecognized parameter #{name}:#{param} found in #{loaded_path}"
+          warn Rainbow("Warning: unrecognized parameter #{name}:#{param} " \
+                       "found in #{loaded_path}").yellow
         end
       end
     end
+
+    def validate_enforced_styles(valid_cop_names)
+      valid_cop_names.each do |name|
+        next unless (style = self[name]['EnforcedStyle'])
+        valid = ConfigLoader.default_configuration[name]['SupportedStyles']
+        next if valid.include?(style)
+
+        msg = "invalid EnforcedStyle '#{style}' for #{name} found in " \
+              "#{loaded_path}\n" \
+              "Valid choices are: #{valid.join(', ')}"
+        fail ValidationError, msg
+      end
+    end
+
+    def reject_obsolete_parameters
+      check_obsolete_parameter('Style/SpaceAroundOperators',
+                               'MultiSpaceAllowedForOperators',
+                               'If your intention was to allow extra spaces ' \
+                               'for alignment, please use AllowForAlignment: ' \
+                               'true instead.')
+      check_obsolete_parameter('AllCops', 'RunRailsCops',
+                               "Use the following configuration instead:\n" \
+                               "Rails:\n  Enabled: true")
+    end
+
+    def check_obsolete_parameter(cop, parameter, alternative = nil)
+      if key?(cop) && self[cop].key?(parameter)
+        fail ValidationError, "obsolete parameter #{parameter} (for #{cop}) " \
+                              "found in #{loaded_path}" \
+                              "#{"\n" if alternative}#{alternative}"
+      end
+    end
+
+    def reject_obsolete_cops
+      if key?('Style/TrailingComma')
+        fail ValidationError, 'The `Style/TrailingComma` cop no longer ' \
+                              'exists. Please use ' \
+                              '`Style/TrailingCommaInLiteral` and/or ' \
+                              "`Style/TrailingCommaInArguments` instead.\n" \
+                              "(configuration found in #{loaded_path})"
+      end
+    end
+
+    def check_target_ruby
+      target = self['AllCops'] && self['AllCops']['TargetRubyVersion']
+      return unless target
+
+      unless KNOWN_RUBIES.include?(target)
+        fail ValidationError, "Unknown Ruby version #{target.inspect} found " \
+                              'in `TargetRubyVersion` parameter (in ' \
+                              "#{loaded_path}).\nKnown versions: " \
+                              "#{KNOWN_RUBIES.join(', ')}"
+      end
+    end
   end
 end