rubocop 0.34.2 → 0.35.0

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for a line break before the first element in a
+      # multi-line hash.
+      #
+      # @example
+      #
+      #     # bad
+      #     { a: 1,
+      #       b: 2}
+      #
+      #     # good
+      #     {
+      #       a: 1,
+      #       b: 2 }
+      class FirstHashElementLineBreak < Cop
+        include FirstElementLineBreak
+
+        MSG = 'Add a line break before the first element of a ' \
+              'multi-line hash.'
+
+        def on_hash(node)
+          if node.loc.begin
+            check_children_line_break(node, node.children)
+          elsif method_uses_parens?(node.parent, node)
+            check_children_line_break(node, node.children, node.parent)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for a line break before the first argument in a
+      # multi-line method call.
+      #
+      # @example
+      #
+      #     # bad
+      #     method(foo, bar,
+      #       baz)
+      #
+      #     # good
+      #     method(
+      #       foo, bar,
+      #       baz)
+      #
+      #     # ignored
+      #     method foo, bar,
+      #       baz
+      class FirstMethodArgumentLineBreak < Cop
+        include FirstElementLineBreak
+
+        MSG = 'Add a line break before the first argument of a ' \
+              'multi-line method argument list.'
+
+        def on_send(node)
+          _receiver, _name, *args = *node
+
+          check_method_line_break(node, args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for a line break before the first parameter in a
+      # multi-line method parameter definition.
+      #
+      # @example
+      #
+      #     # bad
+      #     def method(foo, bar,
+      #         baz)
+      #       do_something
+      #     end
+      #
+      #     # good
+      #     def method(
+      #         foo, bar,
+      #         baz)
+      #       do_something
+      #     end
+      #
+      #     # ignored
+      #     def method foo,
+      #         bar
+      #       do_something
+      #     end
+      class FirstMethodParameterLineBreak < Cop
+        include OnMethodDef
+        include FirstElementLineBreak
+
+        MSG = 'Add a line break before the first parameter of a ' \
+              'multi-line method parameter list.'
+
+        def on_method_def(node, _method_name, args, _body)
+          check_method_line_break(node, args.to_a)
+        end
+      end
+    end
+  end
+end

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

@@ -9,6 +9,7 @@ module RuboCop
       # allowed, however.
       class For < Cop
         include ConfigurableEnforcedStyle
+        EACH_LENGTH = 'each'.length
 
         def on_for(node)
           if style == :each
@@ -32,7 +33,7 @@ module RuboCop
           if style == :for
             end_pos = method.loc.expression.end_pos
             range = Parser::Source::Range.new(processed_source.buffer,
-                                              end_pos - 'each'.length,
+                                              end_pos - EACH_LENGTH,
                                               end_pos)
             add_offense(range, range, 'Prefer `for` over `each`.') do
               opposite_style_detected

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

@@ -9,6 +9,8 @@ module RuboCop
       class IfUnlessModifier < Cop
         include StatementModifier
 
+        ASSIGNMENT_TYPES = [:lvasgn, :casgn, :cvasgn, :gvasgn, :ivasgn, :masgn]
+
         def message(keyword)
           "Favor modifier `#{keyword}` usage when having a single-line body." \
           ' Another good alternative is the usage of control flow `&&`/`||`.'
@@ -20,10 +22,38 @@ module RuboCop
           return if modifier_if?(node)
           return if elsif?(node)
           return if if_else?(node)
+          return if chained?(node)
           return unless fit_within_line_as_modifier_form?(node)
           add_offense(node, :keyword, message(node.loc.keyword.source))
         end
 
+        def chained?(node)
+          # Don't register offense for `if ... end.method`
+          return false if node.parent.nil? || !node.parent.send_type?
+          receiver = node.parent.children[0]
+          node.equal?(receiver)
+        end
+
+        def parenthesize?(node)
+          # Parenthesize corrected expression if changing to modifier-if form
+          # would change the meaning of the parent expression
+          # (due to the low operator precedence of modifier-if)
+          return false if node.parent.nil?
+          return true if ASSIGNMENT_TYPES.include?(node.parent.type)
+
+          if node.parent.send_type?
+            _receiver, _name, *args = *node.parent
+            return !method_uses_parens?(node.parent, args.first)
+          end
+
+          false
+        end
+
+        def method_uses_parens?(node, limit)
+          source = node.loc.expression.source_line[0...limit.loc.column]
+          source =~ /\s*\(\s*$/
+        end
+
         def autocorrect(node)
           cond, body, _else = if_node_parts(node)
 
@@ -36,6 +66,7 @@ module RuboCop
           if first_line_comment
             oneline << ' ' << first_line_comment.loc.expression.source
           end
+          oneline = "(#{oneline})" if parenthesize?(node)
 
           ->(corrector) { corrector.replace(node.loc.expression, oneline) }
         end

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

@@ -7,14 +7,37 @@ module RuboCop
       # where the opening brace and the first key are on separate lines. The
       # other keys' indentations are handled by the AlignHash cop.
       #
-      # Hash literals that are arguments in a method call with parentheses, and
-      # where the opening curly brace of the hash is on the same line as the
-      # opening parenthesis of the method call, shall have their first key
-      # indented one step (two spaces) more than the position inside the
-      # opening parenthesis.
+      # By default, Hash literals that are arguments in a method call with
+      # parentheses, and where the opening curly brace of the hash is on the
+      # same line as the opening parenthesis of the method call, shall have
+      # their first key indented one step (two spaces) more than the position
+      # inside the opening parenthesis.
       #
       # Other hash literals shall have their first key indented one step more
       # than the start of the line where the opening curly brace is.
+      #
+      # This default style is called 'special_inside_parentheses'. Alternative
+      # styles are 'consistent' and 'align_braces'. Here are examples:
+      #
+      #     # special_inside_parentheses
+      #     hash = {
+      #       key: :value
+      #     }
+      #     but_in_a_method_call({
+      #                            its_like: :this
+      #                          })
+      #     # consistent
+      #     hash = {
+      #       key: :value
+      #     }
+      #     and_in_a_method_call({
+      #       no: :difference
+      #     })
+      #     # align_braces
+      #     and_now_for_something = {
+      #                               completely: :different
+      #                             }
+      #
       class IndentHash < Cop
         include AutocorrectAlignment
         include ConfigurableEnforcedStyle
@@ -62,13 +85,16 @@ module RuboCop
         end
 
         def check_right_brace(right_brace, left_brace, left_parenthesis)
+          # if the right brace is on the same line as the last value, accept
           return if right_brace.source_line[0...right_brace.column] =~ /\S/
 
           expected_column = base_column(left_brace, left_parenthesis)
           @column_delta = expected_column - right_brace.column
           return if @column_delta == 0
 
-          msg = if style == :special_inside_parentheses && left_parenthesis
+          msg = if style == :align_braces
+                  'Indent the right brace the same as the left brace.'
+                elsif style == :special_inside_parentheses && left_parenthesis
                   'Indent the right brace the same as the first position ' \
                   'after the preceding left parenthesis.'
                 else
@@ -93,15 +119,24 @@ module RuboCop
         end
 
         def check_first_pair(first_pair, left_brace, left_parenthesis, offset)
-          column = first_pair.loc.expression.column
+          actual_column = first_pair.loc.expression.column
           expected_column = base_column(left_brace, left_parenthesis) +
                             configured_indentation_width + offset
-          @column_delta = expected_column - column
+          @column_delta = expected_column - actual_column
 
           if @column_delta == 0
-            correct_style_detected
+            # which column was actually used as 'base column' for indentation?
+            # (not the column which we think should be the 'base column',
+            # but the one which has actually been used for that purpose)
+            base_column = actual_column - configured_indentation_width - offset
+            styles = detected_styles(base_column, left_parenthesis, left_brace)
+            if styles.size > 1
+              ambiguous_style_detected(*styles)
+            else
+              correct_style_detected
+            end
           else
-            incorrect_style_detected(column, offset, first_pair,
+            incorrect_style_detected(actual_column, offset, first_pair,
                                      left_parenthesis, left_brace)
           end
         end
@@ -110,17 +145,29 @@ module RuboCop
                                      left_parenthesis, left_brace)
           add_offense(first_pair, :expression,
                       message(base_description(left_parenthesis))) do
-            if column == unexpected_column(left_brace, left_parenthesis,
-                                           offset)
-              opposite_style_detected
-            else
-              unrecognized_style_detected
-            end
+            base_column = column - configured_indentation_width - offset
+            styles = detected_styles(base_column, left_parenthesis, left_brace)
+            ambiguous_style_detected(*styles)
           end
         end
 
+        def detected_styles(column, left_parenthesis, left_brace)
+          styles = []
+          if column == (left_brace.source_line =~ /\S/)
+            styles << :consistent
+            styles << :special_inside_parentheses unless left_parenthesis
+          end
+          if left_parenthesis && column == left_parenthesis.column + 1
+            styles << :special_inside_parentheses
+          end
+          styles << :align_braces if column == left_brace.column
+          styles
+        end
+
         def base_column(left_brace, left_parenthesis)
-          if left_parenthesis && style == :special_inside_parentheses
+          if style == :align_braces
+            left_brace.column
+          elsif left_parenthesis && style == :special_inside_parentheses
             left_parenthesis.column + 1
           else
             left_brace.source_line =~ /\S/
@@ -129,32 +176,15 @@ module RuboCop
 
         # Returns the description of what the correct indentation is based on.
         def base_description(left_parenthesis)
-          if left_parenthesis && style == :special_inside_parentheses
+          if style == :align_braces
+            'the position of the opening brace'
+          elsif left_parenthesis && style == :special_inside_parentheses
             'the first position after the preceding left parenthesis'
           else
             'the start of the line where the left curly brace is'
           end
         end
 
-        # Returns the "unexpected column", which is the column that would be
-        # correct if the configuration was changed.
-        def unexpected_column(left_brace, left_parenthesis, offset)
-          # Set a crazy value by default, indicating that there's no other
-          # configuration that can be chosen to make the used indentation
-          # accepted.
-          unexpected_base_column = -1000
-
-          if left_parenthesis
-            unexpected_base_column = if style == :special_inside_parentheses
-                                       left_brace.source_line =~ /\S/
-                                     else
-                                       left_parenthesis.column + 1
-                                     end
-          end
-
-          unexpected_base_column + configured_indentation_width + offset
-        end
-
         def message(base_description)
           format('Use %d spaces for indentation in a hash, relative to %s.',
                  configured_indentation_width, base_description)

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

@@ -257,7 +257,7 @@ module RuboCop
           return false unless body_node.loc.column == first_char_pos_on_line
 
           if [:rescue, :ensure].include?(body_node.type)
-            block_body, *_ = *body_node
+            block_body, = *body_node
             return unless block_body
           end
 

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

@@ -6,13 +6,14 @@ module RuboCop
       # This cop checks whether comments have a leading space
       # after the # denoting the start of the comment. The
       # leading space is not required for some RDoc special syntax,
-      # like #++, #--, #:nodoc, etc.
+      # like #++, #--, #:nodoc, etc. Neither is it required for
+      # =begin/=end comments.
       class LeadingCommentSpace < Cop
         MSG = 'Missing space after #.'
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
-            next unless comment.text =~ /^#+[^#\s=:+-]/
+            next unless comment.text =~ /\A#+[^#\s=:+-]/
             next if comment.text.start_with?('#!') && comment.loc.line == 1
 
             add_offense(comment, :expression)

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

@@ -37,6 +37,14 @@ module RuboCop
               mlhs_node, _mrhs_node = *asgn_node
               asgn_node = mlhs_node.children[node.sibling_index]
             end
+            # `obj.method = value` parses as (send ... :method= ...), and will
+            # not be returned as an `asgn_node` here
+            # however, `obj.method ||= value` parses as (or-asgn (send ...) ...)
+            # which IS an `asgn_node`
+            if asgn_node.or_asgn_type? || asgn_node.and_asgn_type?
+              asgn_node, _value = *asgn_node
+              return false if asgn_node.send_type?
+            end
 
             asgn_node.loc.name.source == method_name.to_s
           end

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

@@ -10,7 +10,9 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         def on_method_def(node, _method_name, args, _body)
-          if style == :require_parentheses
+          if style == :require_parentheses ||
+             (style == :require_no_parentheses_except_multiline &&
+              args.multiline?)
             if arguments?(args) && !parentheses?(args)
               missing_parentheses(node, args)
             else
@@ -25,7 +27,11 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            if style == :require_parentheses
+            if node.args_type?
+              # offense is registered on args node when parentheses are unwanted
+              corrector.replace(node.loc.begin, ' ')
+              corrector.remove(node.loc.end)
+            else
               args_expr = args_node(node).loc.expression
               args_with_space = range_with_surrounding_space(args_expr, :left)
               just_space = Parser::Source::Range.new(args_expr.source_buffer,
@@ -33,9 +39,6 @@ module RuboCop
                                                      args_expr.begin_pos)
               corrector.replace(just_space, '(')
               corrector.insert_after(args_expr, ')')
-            elsif style == :require_no_parentheses
-              corrector.replace(node.loc.begin, ' ')
-              corrector.remove(node.loc.end)
             end
           end
         end
@@ -45,13 +48,13 @@ module RuboCop
         def missing_parentheses(node, args)
           add_offense(node, args.loc.expression,
                       'Use def with parentheses when there are parameters.') do
-            opposite_style_detected
+            unexpected_style_detected(:require_no_parentheses)
           end
         end
 
         def unwanted_parentheses(args)
           add_offense(args, :expression, 'Use def without parentheses.') do
-            opposite_style_detected
+            unexpected_style_detected(:require_parentheses)
           end
         end
 

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

@@ -98,7 +98,7 @@ module RuboCop
             article = kw =~ /^[iu]/ ? 'an' : 'a'
             "a #{kind} in #{article} `#{kw}` statement"
           else
-            'an expression' + (assignment?(node) ? ' in an assignment' : '')
+            'an expression' + (assignment_rhs?(node) ? ' in an assignment' : '')
           end
         end
 
@@ -142,7 +142,7 @@ module RuboCop
 
         def should_align?(node, given_style)
           given_style == :aligned && (kw_node_with_special_indentation(node) ||
-                                      assignment?(node))
+                                      assignment_rhs?(node))
         end
 
         def kw_node_with_special_indentation(node)
@@ -160,17 +160,12 @@ module RuboCop
           end
         end
 
-        def assignment?(node)
-          node.each_ancestor.find do |a|
-            case a.type
-            when :send
-              _receiver, method_name, *_args = *a
-              # The []= operator is the only assignment operator that is parsed
-              # as a :send node.
-              method_name == :[]=
-            when *ASGN_NODES
-              true
-            end
+        def assignment_rhs?(node)
+          node.ancestors.unshift(node).each_cons(2).any? do |child, parent|
+            return true if parent.asgn_rhs.equal?(child)
+            grandparent = parent.parent
+            return true if grandparent && grandparent.masgn_type? &&
+                           grandparent.asgn_rhs.equal?(parent)
           end
         end