rubocop 0.28.0 → 0.29.0

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

@@ -7,11 +7,11 @@ module RuboCop
       #
       # @example
       #
-      # class A
-      #  def test
-      #   puts 'hello'
-      #  end
-      # end
+      #   class A
+      #    def test
+      #     puts 'hello'
+      #    end
+      #   end
       class IndentationWidth < Cop # rubocop:disable Metrics/ClassLength
         include AutocorrectAlignment
         include OnMethodDef
@@ -128,9 +128,9 @@ module RuboCop
           return if modifier_if?(node)
 
           case node.loc.keyword.source
-          when 'if'     then _condition, body, else_clause = *node
-          when 'unless' then _condition, else_clause, body = *node
-          else               _condition, body = *node
+          when 'if', 'elsif' then _condition, body, else_clause = *node
+          when 'unless'      then _condition, else_clause, body = *node
+          else                    _condition, body = *node
           end
 
           check_if(node, body, else_clause, base.loc) if body
@@ -164,12 +164,11 @@ module RuboCop
           check_indentation(base_loc, body)
           return unless else_clause
 
-          if elsif?(else_clause)
-            _condition, inner_body, inner_else_clause = *else_clause
-            check_if(else_clause, inner_body, inner_else_clause, base_loc)
-          else
-            check_indentation(node.loc.else, else_clause)
-          end
+          # If the else clause is an elsif, it will get its own on_if call so
+          # we don't need to process it here.
+          return if elsif?(else_clause)
+
+          check_indentation(node.loc.else, else_clause)
         end
 
         def check_indentation(base_loc, body_node)

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

@@ -8,6 +8,7 @@ module RuboCop
       # anonymous functions.
       class Lambda < Cop
         SINGLE_MSG = 'Use the new lambda literal syntax `->(params) {...}`.'
+        SINGLE_NO_ARG_MSG = 'Use the new lambda literal syntax `-> {...}`.'
         MULTI_MSG = 'Use the `lambda` method for multi-line lambdas.'
 
         TARGET = s(:send, nil, :lambda)
@@ -17,14 +18,14 @@ module RuboCop
           # (block
           #   (send nil :lambda)
           #   ...)
-          block_method, = *node
+          block_method, args, = *node
 
           return unless block_method == TARGET
           selector = block_method.loc.selector.source
           lambda_length = lambda_length(node)
 
           if selector != '->' && lambda_length == 0
-            add_offense(block_method, :expression, SINGLE_MSG)
+            add_offense_for_single_line(block_method, args)
           elsif selector == '->' && lambda_length > 0
             add_offense(block_method, :expression, MULTI_MSG)
           end
@@ -32,12 +33,57 @@ module RuboCop
 
         private
 
+        def add_offense_for_single_line(block_method, args)
+          if args.children.empty?
+            add_offense(block_method, :expression, SINGLE_NO_ARG_MSG)
+          else
+            add_offense(block_method, :expression, SINGLE_MSG)
+          end
+        end
+
         def lambda_length(block_node)
           start_line = block_node.loc.begin.line
           end_line = block_node.loc.end.line
 
           end_line - start_line
         end
+
+        def autocorrect(node)
+          ancestor = node.ancestors.first
+
+          @corrections << lambda do |corrector|
+            if node.loc.expression.source == 'lambda'
+              autocorrect_old_to_new(corrector, ancestor)
+            else
+              autocorrect_new_to_old(corrector, ancestor)
+            end
+          end
+        end
+
+        def autocorrect_new_to_old(corrector, node)
+          block_method, args = *node
+          corrector.replace(block_method.loc.expression, 'lambda')
+          return if args.children.empty?
+
+          arg_str = " |#{lambda_arg_string(args)}|"
+          corrector.remove(args.loc.expression)
+          corrector.insert_after(node.loc.begin, arg_str)
+        end
+
+        def autocorrect_old_to_new(corrector, node)
+          block_method, args = *node
+          corrector.replace(block_method.loc.expression, '->')
+          return if args.children.empty?
+
+          arg_str = "(#{lambda_arg_string(args)})"
+          whitespace_and_old_args = node.loc.begin.end.join(args.loc.end)
+          corrector.insert_after(block_method.loc.expression, arg_str)
+          corrector.remove(whitespace_and_old_args)
+        end
+
+        def lambda_arg_string(args)
+          args.children.map { |a| a.loc.expression.source }.join(', ')
+        end
       end
     end
   end

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

@@ -21,70 +21,66 @@ module RuboCop
       #
       class LineEndConcatenation < Cop
         MSG = 'Use `\\` instead of `+` or `<<` to concatenate those strings.'
+        CONCAT_TOKEN_TYPES = [:tPLUS, :tLSHFT].freeze
+        SIMPLE_STRING_TOKEN_TYPE = :tSTRING
+        COMPLEX_STRING_EDGE_TOKEN_TYPES = [:tSTRING_BEG, :tSTRING_END].freeze
+        HIGH_PRECEDENCE_OP_TOKEN_TYPES = [:tSTAR2, :tPERCENT, :tDOT,
+                                          :tLBRACK2].freeze
+        QUOTE_DELIMITERS = %w(' ").freeze
 
-        def on_send(node)
-          add_offense(node, :selector) if offending_node?(node)
+        def investigate(processed_source)
+          processed_source.tokens.each_index do |index|
+            check_token_set(index)
+          end
         end
 
-        def autocorrect(node)
+        def autocorrect(operator_range)
           @corrections << lambda do |corrector|
-            # replace + with \
-            corrector.replace(node.loc.selector, '\\')
+            corrector.replace(operator_range, '\\')
           end
         end
 
         private
 
-        def concat?(method)
-          [:+, :<<].include?(method)
-        end
-
-        def offending_node?(node)
-          receiver, method, first_arg = *node
-
-          return false unless concat?(method)
-
-          return false unless final_node_is_string_type?(receiver)
-
-          return false unless root_node_is_string_type?(first_arg)
+        def check_token_set(index)
+          predecessor, operator, successor = processed_source.tokens[index, 3]
+          return unless successor
+          return unless CONCAT_TOKEN_TYPES.include?(operator.type)
+          return unless standard_string_literal?(predecessor)
+          return unless standard_string_literal?(successor)
+          return if operator.pos.line == successor.pos.line
 
-          expression = node.loc.expression.source
-          concatenator_at_line_end?(expression)
-        end
-
-        def concatenator_at_line_end?(expression)
-          # check if the first line of the expression ends with a + or a <<
-          expression =~ /.+(\+|<<)\s*$/
-        end
+          next_successor = token_after_last_string(successor, index)
+          return if next_successor &&
+                    HIGH_PRECEDENCE_OP_TOKEN_TYPES.include?(next_successor.type)
 
-        def string_type?(node)
-          return false unless [:str, :dstr].include?(node.type)
-          # strings like __FILE__ are of no interest
-          return false unless node.loc.respond_to?(:begin)
-
-          # we care only about quotes-delimited literals
-          if node.loc.begin
-            ["'", '"'].include?(node.loc.begin.source)
-          elsif node.children.any?
-            node.children.map { |child| string_type?(child) }.all?
-          end
+          add_offense(operator.pos, operator.pos)
         end
 
-        def final_node_is_string_type?(node)
-          if node.type == :send
-            _, method, first_arg = *node
-            concat?(method) && final_node_is_string_type?(first_arg)
-          else
-            string_type?(node)
+        def token_after_last_string(successor, base_index)
+          index = base_index + 3
+          begin_token, end_token = COMPLEX_STRING_EDGE_TOKEN_TYPES
+          if successor.type == begin_token
+            ends_to_find = 1
+            while ends_to_find > 0
+              case processed_source.tokens[index].type
+              when begin_token then ends_to_find += 1
+              when end_token then ends_to_find -= 1
+              end
+              index += 1
+            end
           end
+          processed_source.tokens[index]
         end
 
-        def root_node_is_string_type?(node)
-          if node.type == :send
-            receiver, method, _ = *node
-            concat?(method) && root_node_is_string_type?(receiver)
+        def standard_string_literal?(token)
+          case token.type
+          when SIMPLE_STRING_TOKEN_TYPE
+            true
+          when *COMPLEX_STRING_EDGE_TOKEN_TYPES
+            QUOTE_DELIMITERS.include?(token.text)
           else
-            string_type?(node)
+            false
           end
         end
       end

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

@@ -9,9 +9,9 @@ module RuboCop
       #
       # @example
       #
-      # a do
-      #   b
-      # end.c
+      #   a do
+      #     b
+      #   end.c
       class MethodCalledOnDoEndBlock < Cop
         MSG = 'Avoid chaining a method call on a do...end block.'
 

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

@@ -7,10 +7,10 @@ module RuboCop
       #
       # @example
       #
-      # module Test
-      #   extend self
+      #   module Test
+      #     extend self
       #
-      #   ...
+      #     ...
       # end
       class ModuleFunction < Cop
         MSG = 'Use `module_function` instead of `extend self`.'

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Style
       # This cop checks whether the multiline do end blocks have a newline
-      # after the start of the block.
+      # after the start of the block. Additionally, it checks whether the block
+      # arguments, if any, are on the same line as the start of the block.
       #
       # @example
       #   # bad
@@ -12,6 +13,12 @@ module RuboCop
       #     bar(i)
       #   end
       #
+      #   # bad
+      #   blah do
+      #     |i| foo(i)
+      #     bar(i)
+      #   end
+      #
       #   # good
       #   blah do |i|
       #     foo(i)
@@ -30,6 +37,8 @@ module RuboCop
       #   }
       class MultilineBlockLayout < Cop
         MSG = 'Block body expression is on the same line as the block start.'
+        ARG_MSG = 'Block argument expression is not on the same line as the ' \
+                  'block start.'
 
         def on_block(node)
           end_loc = node.loc.end
@@ -38,35 +47,74 @@ module RuboCop
 
           # A block node has three children: the block start,
           # the arguments, and the expression. We care if the block start
-          # and the expression start on the same line.
-          last_expression = node.children.last
-          return unless last_expression
-          expression_loc = last_expression.loc
-          return unless do_loc.line == expression_loc.line
+          # with arguments and the expression start on the same line.
+          _block_start, args, last_expression = node.children
 
-          expression = last_expression.loc.expression
+          if !args.children.empty? && do_loc.line != args.loc.end.line
+            add_offense_for_expression(node, args, ARG_MSG)
+          else
+            return unless last_expression
+            expression_loc = last_expression.loc
+            return unless do_loc.line == expression_loc.line
+            add_offense_for_expression(node, last_expression, MSG)
+          end
+        end
+
+        def add_offense_for_expression(node, expr, msg)
+          expression = expr.loc.expression
           range = Parser::Source::Range.new(expression.source_buffer,
                                             expression.begin_pos,
                                             expression.end_pos)
 
-          add_offense(node, range)
+          add_offense(node, range, msg)
         end
 
         def autocorrect(node)
           @corrections << lambda do |corrector|
-            _method, _args, block_body = *node
-            first_node = if block_body.type == :begin
-                           block_body.children.first
-                         else
-                           block_body
-                         end
+            _method, args, block_body = *node
+            unless args.children.empty? ||
+                   args.loc.end.line == node.loc.begin.line
+              autocorrect_arguments(corrector, node, args, block_body)
+              expr_before_body = args.loc.expression.end
+            end
 
-            block_start_col = node.loc.expression.column
+            return unless block_body
 
-            corrector.insert_before(first_node.loc.expression,
-                                    "\n  #{' ' * block_start_col}")
+            expr_before_body ||= node.loc.begin
+            if expr_before_body.line == block_body.loc.line
+              autocorrect_body(corrector, node, block_body)
+            end
           end
         end
+
+        def autocorrect_arguments(corrector, node, args, block_body)
+          end_pos = if block_body
+                      block_body.loc.expression.begin_pos
+                    else
+                      node.loc.end.begin.begin_pos - 1
+                    end
+          range = Parser::Source::Range.new(args.loc.expression.source_buffer,
+                                            node.loc.begin.end.begin_pos,
+                                            end_pos)
+          corrector.replace(range, " |#{block_arg_string(args)}|")
+        end
+
+        def autocorrect_body(corrector, node, block_body)
+          first_node = if block_body.type == :begin
+                         block_body.children.first
+                       else
+                         block_body
+                       end
+
+          block_start_col = node.loc.expression.column
+
+          corrector.insert_before(first_node.loc.expression,
+                                  "\n  #{' ' * block_start_col}")
+        end
+
+        def block_arg_string(args)
+          args.children.map { |a| a.loc.expression.source }.join(', ')
+        end
       end
     end
   end

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

@@ -25,8 +25,9 @@ module RuboCop
         end
 
         def on_send(node)
-          receiver, _method_name, *_args = *node
+          receiver, method_name, *_args = *node
           return unless receiver
+          return if method_name == :[] # Don't check parameters inside [].
 
           lhs, rhs = left_hand_side(receiver), right_hand_side(node)
           range = offending_range(node, lhs, rhs, style)

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

@@ -18,10 +18,10 @@ module RuboCop
             parent_type = node.parent ? node.parent.type : nil
             if [:dstr, :xstr, :regexp].include?(parent_type)
               corrector.replace(node.loc.expression,
-                                "{Regexp.last_match[#{backref}]}")
+                                "{Regexp.last_match(#{backref})}")
             else
               corrector.replace(node.loc.expression,
-                                "Regexp.last_match[#{backref}]")
+                                "Regexp.last_match(#{backref})")
             end
           end
         end

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

@@ -26,6 +26,18 @@ module RuboCop
 
           add_offense(first_arg, :expression) if first_arg == TARGET_NODE
         end
+
+        # switch `raise RuntimeError, 'message'` to `raise 'message'`
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            start_range = node.loc.expression.begin
+            no_comma = range_with_surrounding_comma(node.loc.expression.end,
+                                                    :right)
+            comma_range = start_range.join(no_comma)
+            final_range = range_with_surrounding_space(comma_range, :right)
+            corrector.replace(final_range, '')
+          end
+        end
       end
     end
   end

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

@@ -62,6 +62,33 @@ module RuboCop
           operator = rhs.loc.operator.source
           add_offense(node, :expression, format(MSG, operator))
         end
+
+        def autocorrect(node)
+          _var_name, rhs = *node
+
+          if rhs.type == :send
+            autocorrect_send_node(node, rhs)
+          elsif [:and, :or].include?(rhs.type)
+            autocorrect_boolean_node(node, rhs)
+          end
+        end
+
+        def autocorrect_send_node(node, rhs)
+          _receiver, method_name, args = *rhs
+          apply_autocorrect(node, rhs, method_name.to_s, args)
+        end
+
+        def autocorrect_boolean_node(node, rhs)
+          _first_operand, second_operand = *rhs
+          apply_autocorrect(node, rhs, rhs.loc.operator.source, second_operand)
+        end
+
+        def apply_autocorrect(node, rhs, operator, new_rhs)
+          @corrections << lambda do |corrector|
+            corrector.insert_before(node.loc.operator, operator)
+            corrector.replace(rhs.loc.expression, new_rhs.loc.expression.source)
+          end
+        end
       end
     end
   end