rubocop 0.10.0 → 0.11.0

data/lib/rubocop/config_store.rb

@@ -31,7 +31,10 @@ module Rubocop
       dir = File.dirname(file)
       @path_cache[dir] ||= Config.configuration_file_for(dir)
       path = @path_cache[dir]
-      @object_cache[path] ||= Config.configuration_from_file(path)
+      @object_cache[path] ||= begin
+                                print "For #{dir}: " if Config.debug?
+                                Config.configuration_from_file(path)
+                              end
     end
   end
 end

data/lib/rubocop/cop/commissioner.rb

@@ -70,9 +70,7 @@ module Rubocop
       # its own processing.
       def invoke_cops_callback(processed_source)
         @cops.each do |cop|
-          if cop.respond_to?(:investigate)
-            cop.investigate(processed_source)
-          end
+          cop.investigate(processed_source) if cop.respond_to?(:investigate)
         end
       end
 
@@ -80,7 +78,7 @@ module Rubocop
         cop.send callback, node
       rescue => e
         if @options[:raise_error]
-          fail e
+          raise e
         else
           @errors[cop] << e
         end

data/lib/rubocop/cop/cop.rb

@@ -11,16 +11,16 @@ module Rubocop
     # A commissioner object is responsible for traversing the AST and invoking
     # the specific callbacks on each cop.
     # If a cop needs to do its own processing of the AST or depends on
-    # something else it should define the #investigate method and do
+    # something else it should define the `#investigate` method and do
     # the processing there.
     #
     # @example
     #
-    # class CustomCop < Cop
-    #   def investigate(processed_source)
-    #     # Do custom processing
+    #   class CustomCop < Cop
+    #     def investigate(processed_source)
+    #       # Do custom processing
+    #     end
     #   end
-    # end
     class Cop
       extend AST::Sexp
 
@@ -73,11 +73,11 @@ module Rubocop
         @corrections = []
       end
 
-      def do_autocorrect(node)
-        autocorrect_action(node) if autocorrect
+      def do_autocorrect(node, *args)
+        autocorrect_action(node, *args) if autocorrect
       end
 
-      def autocorrect_action(node)
+      def autocorrect_action(node, *args)
       end
 
       def add_offence(severity, location, message)

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

@@ -26,6 +26,9 @@ module Rubocop
         def check(node)
           condition, = *node
 
+          # assignments inside blocks are not what we're looking for
+          return if condition.type == :block
+
           on_node([:begin, *ASGN_NODES], condition) do |asgn_node|
             # skip safe assignment nodes if safe assignment is allowed
             return if safe_assignment_allowed? && safe_assignment?(asgn_node)

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

@@ -21,9 +21,7 @@ module Rubocop
 
         def on_block(node)
           return if already_processed_node?(node)
-          method, = *node
-          start_node = method.loc.expression.source =~ /\n/ ? method : node
-          check_block_alignment(start_node.loc.expression, node.loc)
+          check_block_alignment(node, node)
         end
 
         def on_and(node)
@@ -31,7 +29,7 @@ module Rubocop
 
           _left, right = *node
           if right.type == :block
-            check_block_alignment(node.loc.expression, right.loc)
+            check_block_alignment(node, right)
             @inspected_blocks << right
           end
         end
@@ -93,7 +91,7 @@ module Rubocop
           return if already_processed_node?(block_node)
 
           @inspected_blocks << block_node
-          check_block_alignment(begin_node.loc.expression, block_node.loc)
+          check_block_alignment(begin_node, block_node)
         end
 
         def find_block_node(node)
@@ -117,24 +115,16 @@ module Rubocop
           end
         end
 
-        def check_block_alignment(start_loc, block_loc)
-          match = start_loc.source.match(/\n(\s*)((end)?\.\S+)\Z/)
-          if match
-            start_line = start_loc.line + start_loc.source.count("\n")
-            start_column = match.captures[0].length
-            start_source = match.captures[1]
-          else
-            start_line = start_loc.line
-            start_column = start_loc.column
-            start_source = start_loc.source.lines.to_a.first.chomp
-          end
-          end_loc = block_loc.end
-          if block_loc.begin.line != end_loc.line &&
-              start_column != end_loc.column
+        def check_block_alignment(start_node, block_node)
+          start_loc = start_node.loc.expression
+          end_loc = block_node.loc.end
+          if block_node.loc.begin.line != end_loc.line &&
+              start_loc.column != end_loc.column
             add_offence(:warning,
                         end_loc,
                         sprintf(MSG, end_loc.line, end_loc.column,
-                                start_source, start_line, start_column))
+                                start_loc.source.lines.to_a.first.chomp,
+                                start_loc.line, start_loc.column))
           end
         end
 

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

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for useless assignment as the final expression
+      # of a function definition.
+      #
+      # @example
+      #
+      #  def something
+      #    x = 5
+      #  end
+      #
+      #  def something
+      #    x = Something.new
+      #    x.attr = 5
+      #  end
+      class UselessAssignment < Cop
+        MSG = 'Useless assignment to local variable %s.'
+
+        def on_def(node)
+          _name, _args, body = *node
+
+          check_for_useless_assignment(body)
+        end
+
+        def on_defs(node)
+          _target, _name, _args, body = *node
+
+          check_for_useless_assignment(body)
+        end
+
+        private
+
+        def check_for_useless_assignment(body)
+          return unless body
+
+          if body.type == :begin
+            expression = body.children
+          else
+            expression = body
+          end
+
+          last_expr = expression.is_a?(Array) ? expression.last : expression
+
+          if last_expr && last_expr.type == :lvasgn
+            var_name, = *last_expr
+            add_offence(:warning, last_expr.loc.name, MSG.format(var_name))
+          elsif last_expr && last_expr.type == :send
+            receiver, method, _args = *last_expr
+
+            if receiver && receiver.type == :lvar && method =~ /\w=$/
+              add_offence(:warning,
+                          receiver.loc.name,
+                          MSG.format(receiver.loc.name.source))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for comparison of something with itself.
+      #
+      # @example
+      #
+      #  x.top >= x.top
+      class UselessComparison < Cop
+        MSG = 'Comparison of something with itself detected.'
+
+        OPS = %w(== === != < > <= >= <=>)
+
+        def on_send(node)
+          op = node.loc.selector.source
+
+          if OPS.include?(op)
+            receiver, _method, selector = *node
+
+            if receiver == selector
+              add_offence(:warning, node.loc.selector, MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/align_parameters.rb

@@ -12,22 +12,32 @@ module Rubocop
         def on_send(node)
           _receiver, method, *args = *node
 
-          if method != :[]= && args.size > 1
-            first_arg_col = args.first.loc.expression.column
-            prev_arg_line = args.first.loc.expression.line
-            prev_arg_col = first_arg_col
+          return if method == :[]=
+          return if args.size <= 1
 
-            args.each do |arg|
-              cur_arg_line = arg.loc.expression.line
-              cur_arg_col = arg.loc.expression.column
+          first_arg_column = args.first.loc.expression.column
 
-              if cur_arg_line != prev_arg_line &&
-                  cur_arg_col != first_arg_col
-                add_offence(:convention, arg.loc.expression, MSG)
-              end
+          args.each_cons(2) do |prev, current|
+            current_pos = current.loc.expression
 
-              prev_arg_col = cur_arg_col
-              prev_arg_line = cur_arg_line
+            if current_pos.line > prev.loc.expression.line &&
+                current_pos.column != first_arg_column
+              add_offence(:convention, current_pos, MSG)
+              do_autocorrect(current, first_arg_column - current_pos.column)
+            end
+          end
+        end
+
+        def autocorrect_action(node, column_delta)
+          @corrections << lambda do |corrector|
+            expr = node.loc.expression
+            if column_delta > 0
+              corrector.replace(expr, ' ' * column_delta + expr.source)
+            else
+              range = Parser::Source::Range.new(expr.source_buffer,
+                                                expr.begin_pos + column_delta,
+                                                expr.end_pos)
+              corrector.replace(range, expr.source)
             end
           end
         end

data/lib/rubocop/cop/style/and_or.rb

@@ -32,10 +32,22 @@ module Rubocop
         end
 
         def autocorrect_action(node)
-          @corrections << lambda do |corrector|
+          correction = lambda do |corrector|
             replacement = (node.type == :and ? '&&' : '||')
             corrector.replace(node.loc.operator, replacement)
           end
+
+          new_source = rewrite_node(node, correction)
+
+          # Make the correction only if it doesn't change the AST.
+          if node == SourceParser.parse(new_source).ast
+            @corrections << correction
+          end
+        end
+
+        def rewrite_node(node, correction)
+          processed_source = SourceParser.parse(node.loc.expression.source)
+          Corrector.new(processed_source.buffer, [correction]).rewrite
         end
       end
     end

data/lib/rubocop/cop/style/blocks.rb

@@ -9,7 +9,22 @@ module Rubocop
         MULTI_LINE_MSG = 'Avoid using {...} for multi-line blocks.'
         SINGLE_LINE_MSG = 'Prefer {...} over do...end for single-line blocks.'
 
+        def on_send(node)
+          _receiver, method_name, *args = *node
+          if args.any?
+            block = get_block(args.last)
+            if block && !has_parentheses?(node) && !operator?(method_name)
+              # If there are no parentheses around the arguments, then braces
+              # and do-end have different meaning due to how they bind, so we
+              # allow either.
+              ignore_node(block)
+            end
+          end
+        end
+
         def on_block(node)
+          return if ignored_node?(node)
+
           block_length = Util.block_length(node)
           block_begin = node.loc.begin.source
 
@@ -19,6 +34,26 @@ module Rubocop
             add_offence(:convention, node.loc.begin, SINGLE_LINE_MSG)
           end
         end
+
+        private
+
+        def get_block(node)
+          case node.type
+          when :block
+            node
+          when :send
+            receiver, _method_name, *_args = *node
+            get_block(receiver) if receiver
+          end
+        end
+
+        def has_parentheses?(send_node)
+          send_node.loc.begin
+        end
+
+        def operator?(method_name)
+          method_name =~ /^\W/
+        end
       end
     end
   end

data/lib/rubocop/cop/style/character_literal.rb

@@ -10,7 +10,7 @@ module Rubocop
         def on_str(node)
           # Constants like __FILE__ are handled as strings,
           # but don't respond to begin.
-          return unless node.loc.respond_to?(:begin)
+          return unless node.loc.respond_to?(:begin) && node.loc.begin
           return if part_of_ignored_node?(node)
 
           # we don't register an offence for things like ?\C-\M-d

data/lib/rubocop/cop/style/comment_annotation.rb

@@ -8,7 +8,6 @@ module Rubocop
       class CommentAnnotation < Cop
         MSG = 'Annotation keywords shall be all upper case, followed by a ' +
           'colon and a space, then a note describing the problem.'
-        KEYWORDS = %w(TODO FIXME OPTIMIZE HACK REVIEW)
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
@@ -17,7 +16,7 @@ module Rubocop
               margin, first_word, colon, space, note = *match.captures
               if annotation?(first_word, colon, space, note) &&
                   !correct_annotation?(first_word, colon, space, note)
-                start = comment.loc.begin_pos + margin.length
+                start = comment.loc.expression.begin_pos + margin.length
                 length = first_word.length + (colon || '').length
                 range = Parser::Source::Range.new(processed_source.buffer,
                                                   start,
@@ -28,15 +27,31 @@ module Rubocop
           end
         end
 
+        def self.keywords
+          CommentAnnotation.config['Keywords']
+        end
+
         private
 
         def annotation?(first_word, colon, space, note)
-          KEYWORDS.include?(first_word.upcase) && (colon || space || !note)
+          keyword_appearance?(first_word, colon, space) &&
+            !just_first_word_of_sentence?(first_word, colon, space, note)
+        end
+
+        def keyword_appearance?(first_word, colon, space)
+          keyword?(first_word.upcase) && (colon || space)
+        end
+
+        def just_first_word_of_sentence?(first_word, colon, space, note)
+          first_word == first_word.capitalize && !colon && space && note
         end
 
         def correct_annotation?(first_word, colon, space, note)
-          KEYWORDS.include?(first_word) &&
-            (colon && space && note || !colon && !note)
+          keyword?(first_word) && (colon && space && note || !colon && !note)
+        end
+
+        def keyword?(word)
+          CommentAnnotation.keywords.include?(word)
         end
       end
     end

data/lib/rubocop/cop/style/dot_position.rb

@@ -19,7 +19,13 @@ module Rubocop
 
         def proper_dot_position?(node)
           dot_line = node.loc.dot.line
-          selector_line = node.loc.selector.line
+
+          if node.loc.selector
+            selector_line = node.loc.selector.line
+          else
+            # l.(1) has no selector, so we use the opening parenthesis instead
+            selector_line = node.loc.begin.line
+          end
 
           case DotPosition.config['Style'].downcase
           when 'leading' then dot_line == selector_line

data/lib/rubocop/cop/style/empty_line_between_defs.rb

@@ -12,7 +12,7 @@ module Rubocop
           def_start = node.loc.keyword.line
           def_end = node.loc.end.line
 
-          if @prev_def_end && (def_start - @prev_def_end) < 2
+          if @prev_def_end && (def_start - @prev_def_end) == 1
             add_offence(:convention, node.loc.keyword, MSG)
           end
 

data/lib/rubocop/cop/style/favor_modifier.rb

@@ -65,10 +65,10 @@ module Rubocop
           return unless processed_source.ast
           on_node(:if, processed_source.ast) do |node|
             # discard ternary ops, if/else and modifier if/unless nodes
-            return if ternary_op?(node)
-            return if modifier_if?(node)
-            return if elsif?(node)
-            return if if_else?(node)
+            next if ternary_op?(node)
+            next if modifier_if?(node)
+            next if elsif?(node)
+            next if if_else?(node)
 
             if check(node, processed_source.comments)
               add_offence(:convention, node.loc.expression, error_message)