rubocop 0.18.1 → 0.19.0

data/lib/rubocop/cli.rb

@@ -36,6 +36,7 @@ module Rubocop
       !any_failed && !wants_to_quit ? 0 : 1
     rescue => e
       $stderr.puts e.message
+      $stderr.puts e.backtrace
       return 1
     end
 
@@ -73,7 +74,7 @@ module Rubocop
       show_all = @options[:show_cops].empty?
 
       if show_all
-        puts "# Available cops (#{cops.length}) + config for #{Dir.pwd.to_s}: "
+        puts "# Available cops (#{cops.length}) + config for #{Dir.pwd}: "
       end
 
       cops.types.sort!.each { |type| print_cops_of_type(cops, type, show_all) }

data/lib/rubocop/comment_config.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+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
+    COMMENT_DIRECTIVE_REGEXP = Regexp.new(
+      '\A# rubocop : ((?:dis|en)able)\b ((?:\w+,? )+)'.gsub(' ', '\s*')
+    )
+
+    attr_reader :processed_source
+
+    def initialize(processed_source)
+      @processed_source = processed_source
+    end
+
+    def cop_enabled_at_line?(cop, line_number)
+      cop = cop.cop_name if cop.respond_to?(:cop_name)
+      disabled_line_ranges = cop_disabled_line_ranges[cop]
+      disabled_line_ranges.none? { |range| range.include?(line_number) }
+    end
+
+    private
+
+    def cop_disabled_line_ranges
+      @cop_disabled_line_ranges ||= analyze
+    end
+
+    def analyze
+      disabled_line_ranges = Hash.new { |hash, key| hash[key] = [] }
+      disablement_start_line_numbers = {}
+
+      each_mentioned_cop do |cop_name, disabled, line, single_line|
+        if single_line
+          next unless disabled
+          disabled_line_ranges[cop_name] << (line..line)
+        else
+          if disabled
+            disablement_start_line_numbers[cop_name] = line
+          else
+            start_line = disablement_start_line_numbers.delete(cop_name)
+            next unless start_line
+            disabled_line_ranges[cop_name] << (start_line..line)
+          end
+        end
+      end
+
+      disablement_start_line_numbers.each do |cop_name, start_line|
+        disabled_line_ranges[cop_name] << (start_line..Float::INFINITY)
+      end
+
+      disabled_line_ranges
+    end
+
+    def each_mentioned_cop
+      all_cop_names = nil # For performance improvement
+
+      processed_source.comments.each do |comment|
+        match = comment.text.match(COMMENT_DIRECTIVE_REGEXP)
+        next unless match
+
+        switch, cops_string = match.captures
+
+        if cops_string == 'all'
+          all_cop_names ||= Cop::Cop.all.map(&:cop_name)
+          cop_names = all_cop_names
+        else
+          cop_names = cops_string.split(/,\s*/)
+        end
+
+        disabled = (switch == 'disable')
+        comment_line_number = comment.loc.expression.line
+        single_line = !comment_only_line?(comment_line_number)
+
+        cop_names.each do |cop_name|
+          yield cop_name, disabled, comment_line_number, single_line
+        end
+      end
+    end
+
+    def comment_only_line?(line_number)
+      non_comment_token_line_numbers.none? do |non_comment_line_number|
+        non_comment_line_number == line_number
+      end
+    end
+
+    def non_comment_token_line_numbers
+      @non_comment_token_line_numbers ||= begin
+        non_comment_tokens = processed_source.tokens.reject do |token|
+          token.type == :tCOMMENT
+        end
+
+        non_comment_tokens.map { |token| token.pos.line }.uniq
+      end
+    end
+  end
+end

data/lib/rubocop/config.rb

@@ -58,7 +58,7 @@ module Rubocop
           unless COMMON_PARAMS.include?(param) ||
                  default_config[name].key?(param)
             fail ValidationError,
-                 "unrecognized parameter #{name}:#{param} found " +
+                 "unrecognized parameter #{name}:#{param} found " \
                  "in #{loaded_path || self}"
           end
         end

data/lib/rubocop/config_loader.rb

@@ -70,8 +70,9 @@ module Rubocop
         Array(inherit_from).map do |f|
           f = File.join(File.dirname(path), f) unless f.start_with?('/')
           if auto_gen_config? && f.include?(AUTO_GENERATED_FILE)
-            fail "Remove #{AUTO_GENERATED_FILE} from the current " +
-              'configuration before generating it again.'
+            warn "Remove #{AUTO_GENERATED_FILE} from the current " \
+                 'configuration before generating it again.'
+            exit(1)
           end
           print 'Inheriting ' if debug?
           load_file(f)

data/lib/rubocop/config_store.rb

@@ -26,10 +26,14 @@ module Rubocop
                                                         options_config)
     end
 
-    def for(file)
+    def for(file_or_dir)
       return @options_config if @options_config
 
-      dir = File.dirname(file)
+      dir = if File.directory?(file_or_dir)
+              file_or_dir
+            else
+              File.dirname(file_or_dir)
+            end
       @path_cache[dir] ||= ConfigLoader.configuration_file_for(dir)
       path = @path_cache[dir]
       @object_cache[path] ||= begin

data/lib/rubocop/cop/commissioner.rb

@@ -54,10 +54,10 @@ module Rubocop
         prepare(processed_source)
         invoke_cops_callback(processed_source)
         process(processed_source.ast) if processed_source.ast
-        @cops.each_with_object([]) do |cop, offences|
+        @cops.each_with_object([]) do |cop, offenses|
           filename = processed_source.buffer.name
           # ignore files that are of no interest to the cop in question
-          offences.concat(cop.offences) if cop.relevant_file?(filename)
+          offenses.concat(cop.offenses) if cop.relevant_file?(filename)
         end
       end
 

data/lib/rubocop/cop/cop.rb

@@ -2,8 +2,6 @@
 
 module Rubocop
   module Cop
-    class CorrectionNotPossible < Exception; end
-
     # Store for all cops with helper functions
     class CopStore < ::Array
       # @return [Array<String>] list of types for current cops.
@@ -27,7 +25,7 @@ module Rubocop
     #
     # The Cop class is meant to be extended.
     #
-    # Cops track offences and can autocorrect them of the fly.
+    # Cops track offenses and can autocorrect them of the fly.
     #
     # A commissioner object is responsible for traversing the AST and invoking
     # the specific callbacks on each cop.
@@ -47,7 +45,7 @@ module Rubocop
       include Util
       include IgnoredNode
 
-      attr_reader :config, :offences, :corrections
+      attr_reader :config, :offenses, :corrections
       attr_accessor :processed_source # TODO: Bad design.
 
       @all = CopStore.new
@@ -84,7 +82,7 @@ module Rubocop
         @config = config || Config.new
         @options = options || { auto_correct: false, debug: false }
 
-        @offences = []
+        @offenses = []
         @corrections = []
       end
 
@@ -112,32 +110,31 @@ module Rubocop
         respond_to?(:autocorrect, true)
       end
 
-      def add_offence(node, loc, message = nil, severity = nil)
+      def add_offense(node, loc, message = nil, severity = nil)
         location = loc.is_a?(Symbol) ? node.loc.send(loc) : loc
 
-        return if disabled_line?(location.line)
+        return unless enabled_line?(location.line)
+
+        # Don't include the same location twice for one cop.
+        return if @offenses.find { |o| o.location == location }
 
         severity = custom_severity || severity || default_severity
 
-        message = message ? message : message(node)
+        message ||= message(node)
         message = display_cop_names? ? "#{name}: #{message}" : message
 
-        corrected = begin
-                      autocorrect(node) if autocorrect?
-                      autocorrect?
-                    rescue CorrectionNotPossible
-                      false
-                    end
-        @offences << Offence.new(severity, location, message, name, corrected)
+        autocorrect(node) if autocorrect?
+        @offenses << Offense.new(severity, location, message, name,
+                                 autocorrect?)
         yield if block_given?
       end
 
-      def config_to_allow_offences
-        Formatter::DisabledConfigFormatter.config_to_allow_offences[cop_name]
+      def config_to_allow_offenses
+        Formatter::DisabledConfigFormatter.config_to_allow_offenses[cop_name]
       end
 
-      def config_to_allow_offences=(hash)
-        Formatter::DisabledConfigFormatter.config_to_allow_offences[cop_name] =
+      def config_to_allow_offenses=(hash)
+        Formatter::DisabledConfigFormatter.config_to_allow_offenses[cop_name] =
           hash
       end
 
@@ -168,11 +165,10 @@ module Rubocop
         patterns.any? { |pattern| match_path?(pattern, path) }
       end
 
-      def disabled_line?(line_number)
-        return false unless @processed_source
-        disabled_lines = @processed_source.disabled_lines_for_cops[name]
-        return false unless disabled_lines
-        disabled_lines.include?(line_number)
+      def enabled_line?(line_number)
+        return true unless @processed_source
+        @processed_source.comment_config
+          .cop_enabled_at_line?(self, line_number)
       end
 
       def default_severity
@@ -182,11 +178,11 @@ module Rubocop
       def custom_severity
         severity = cop_config && cop_config['Severity']
         if severity
-          if Offence::SEVERITIES.include?(severity.to_sym)
+          if Offense::SEVERITIES.include?(severity.to_sym)
             severity.to_sym
           else
             warn "Warning: Invalid severity '#{severity}'. " +
-                 "Valid severities are #{Offence::SEVERITIES.join(', ')}."
+                 "Valid severities are #{Offense::SEVERITIES.join(', ')}."
                  .color(:red)
           end
         end

data/lib/rubocop/cop/lint/ambiguous_operator.rb

@@ -29,8 +29,8 @@ module Rubocop
         end
 
         MSG_FORMAT = 'Ambiguous %{actual} operator. Parenthesize the method ' \
-                     "arguments if it's surely a %{actual} operator, or add " +
-                     'a whitespace to the right of the %{operator} if it ' +
+                     "arguments if it's surely a %{actual} operator, or add " \
+                     'a whitespace to the right of the %{operator} if it ' \
                      'should be a %{possible}.'
 
         private

data/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb

@@ -18,7 +18,7 @@ module Rubocop
         include ParserDiagnostic
 
         MSG = 'Ambiguous regexp literal. Parenthesize the method arguments ' \
-              "if it's surely a regexp literal, or add a whitespace to the " +
+              "if it's surely a regexp literal, or add a whitespace to the " \
               'right of the / if it should be a division.'
 
         private

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -36,7 +36,7 @@ module Rubocop
 
             # assignment nodes from shorthand ops like ||= don't have operator
             if asgn_node.type != :begin && asgn_node.loc.operator
-              add_offence(asgn_node, :operator)
+              add_offense(asgn_node, :operator)
             end
           end
         end

data/lib/rubocop/cop/lint/block_alignment.rb

@@ -115,13 +115,13 @@ module Rubocop
             match = /\S.*/.match(do_loc.source_line)
             indentation_of_do_line = match.begin(0)
             if end_loc.column != indentation_of_do_line
-              add_offence(nil,
+              add_offense(nil,
                           end_loc,
-                          sprintf(MSG, end_loc.line, end_loc.column,
-                                  start_loc.source.lines.to_a.first.chomp,
-                                  start_loc.line, start_loc.column,
-                                  alt_start_msg(match, start_loc, do_loc,
-                                                indentation_of_do_line)))
+                          format(MSG, end_loc.line, end_loc.column,
+                                 start_loc.source.lines.to_a.first.chomp,
+                                 start_loc.line, start_loc.column,
+                                 alt_start_msg(match, start_loc, do_loc,
+                                               indentation_of_do_line)))
             end
           end
         end

data/lib/rubocop/cop/lint/condition_position.rb

@@ -34,7 +34,7 @@ module Rubocop
 
           if on_different_line?(node.loc.keyword.line,
                                 condition.loc.expression.line)
-            add_offence(condition, :expression,
+            add_offense(condition, :expression,
                         message(node.loc.keyword.source))
           end
         end

data/lib/rubocop/cop/lint/debugger.rb

@@ -27,7 +27,7 @@ module Rubocop
         DEBUGGER_NODES = [DEBUGGER_NODE, PRY_NODE, REMOTE_PRY_NODE]
 
         def on_send(node)
-          add_offence(node, :selector) if DEBUGGER_NODES.include?(node)
+          add_offense(node, :selector) if DEBUGGER_NODES.include?(node)
         end
       end
     end

data/lib/rubocop/cop/lint/deprecated_class_methods.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for uses of the deprecated class method usages.
+      class DeprecatedClassMethods < Cop
+        include AST::Sexp
+
+        MSG = '%s is deprecated in favor of %s.'
+
+        DEPRECATED_METHODS = [
+          [:File, :exists?, :exist?],
+          [:Dir, :exists?, :exist?]
+        ]
+
+        def on_send(node)
+          receiver, method_name, *_args = *node
+
+          DEPRECATED_METHODS.each do |data|
+            next unless receiver == class_node(data)
+            next unless method_name == data[1]
+
+            add_offense(node, :selector,
+                        MSG.format(deprecated_method(data),
+                                   replacement_method(data)))
+          end
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            receiver, method_name, *_args = *node
+
+            DEPRECATED_METHODS.each do |data|
+              next unless receiver == class_node(data)
+              next unless method_name == data[1]
+
+              corrector.replace(node.loc.selector,
+                                data[2].to_s)
+            end
+          end
+        end
+
+        private
+
+        def class_node(data)
+          s(:const, nil, data[0])
+        end
+
+        def deprecated_method(data)
+          format('%s.%s', data[0], data[1])
+        end
+
+        def replacement_method(data)
+          format('%s.%s', data[0], data[2])
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/else_layout.rb

@@ -39,7 +39,7 @@ module Rubocop
             first_else_expr = else_branch.children.first
 
             if first_else_expr.loc.expression.line == node.loc.else.line
-              add_offence(first_else_expr, :expression, message)
+              add_offense(first_else_expr, :expression, message)
             end
           elsif node.loc.respond_to?(:keyword) &&
                 %w(if elsif).include?(node.loc.keyword.source)

data/lib/rubocop/cop/lint/empty_ensure.rb

@@ -10,7 +10,7 @@ module Rubocop
         def on_ensure(node)
           _body, ensure_body = *node
 
-          add_offence(node, :keyword) unless ensure_body
+          add_offense(node, :keyword) unless ensure_body
         end
       end
     end

data/lib/rubocop/cop/lint/end_alignment.rb

@@ -80,15 +80,17 @@ module Rubocop
           when :if, :while, :until
             return if rhs.loc.respond_to?(:question) # ternary
 
-            offset = if style == :variable
-                       rhs.loc.keyword.column - node.loc.expression.column
-                     else
-                       0
-                     end
-            expr = node.loc.expression
-            range = Parser::Source::Range.new(expr.source_buffer,
-                                              expr.begin_pos,
-                                              rhs.loc.keyword.end_pos)
+            if style == :variable
+              expr = node.loc.expression
+              range = Parser::Source::Range.new(expr.source_buffer,
+                                                expr.begin_pos,
+                                                rhs.loc.keyword.end_pos)
+              offset = rhs.loc.keyword.column - node.loc.expression.column
+            else
+              range = rhs.loc.keyword
+              offset = 0
+            end
+
             check_offset(rhs, range.source, offset)
             ignore_node(rhs) # Don't check again.
           end
@@ -108,9 +110,9 @@ module Rubocop
 
           if kw_loc.line != end_loc.line &&
               kw_loc.column != end_loc.column + offset
-            add_offence(nil, end_loc,
-                        sprintf(MSG, end_loc.line, end_loc.column,
-                                alignment_base, kw_loc.line, kw_loc.column)) do
+            add_offense(nil, end_loc,
+                        format(MSG, end_loc.line, end_loc.column,
+                               alignment_base, kw_loc.line, kw_loc.column)) do
               opposite_style_detected
             end
           else