rubocop 0.35.1 → 0.36.0

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

@@ -0,0 +1,91 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether the multiline assignments have a newline
+      # after the assignment operator.
+      #
+      # @example
+      #   # bad (with EnforcedStyle set to new_line)
+      #   foo = if expression
+      #     'bar'
+      #   end
+      #
+      #   # good (with EnforcedStyle set to same_line)
+      #   foo = if expression
+      #     'bar'
+      #   end
+      #
+      #   # good (with EnforcedStyle set to new_line)
+      #   foo =
+      #     if expression
+      #       'bar'
+      #     end
+      #
+      #   # good (with EnforcedStyle set to new_line)
+      #   foo =
+      #     begin
+      #       compute
+      #     rescue => e
+      #       nil
+      #     end
+      class MultilineAssignmentLayout < Cop
+        include CheckAssignment
+        include ConfigurableEnforcedStyle
+
+        NEW_LINE_OFFENSE = 'Right hand side of multi-line assignment is on ' \
+          'the same line as the assignment operator `=`.'.freeze
+
+        SAME_LINE_OFFENSE = 'Right hand side of multi-line assignment is not ' \
+          'on the same line as the assignment operator `=`.'.freeze
+
+        def check_assignment(node, rhs)
+          return unless rhs
+          return unless supported_types.include?(rhs.type)
+          return if rhs.loc.first_line == rhs.loc.last_line
+
+          case style
+          when :new_line
+            check_new_line_offense(node, rhs)
+          when :same_line
+            check_same_line_offense(node, rhs)
+          end
+        end
+
+        def check_new_line_offense(node, rhs)
+          return unless node.loc.operator.line == rhs.loc.line
+
+          add_offense(node, :expression, NEW_LINE_OFFENSE)
+        end
+
+        def check_same_line_offense(node, rhs)
+          return unless node.loc.operator.line != rhs.loc.line
+
+          add_offense(node, :expression, SAME_LINE_OFFENSE)
+        end
+
+        def autocorrect(node)
+          case style
+          when :new_line
+            ->(corrector) { corrector.insert_after(node.loc.operator, "\n") }
+          when :same_line
+            range = Parser::Source::Range.new(
+              node.source_range.source_buffer,
+              node.loc.operator.end_pos,
+              extract_rhs(node).source_range.begin_pos)
+
+            ->(corrector) { corrector.replace(range, ' ') }
+          end
+        end
+
+        private
+
+        def supported_types
+          @supported_types ||= cop_config['SupportedTypes'].map(&:to_sym)
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -14,7 +15,7 @@ module RuboCop
       #     t.object_id
       #   end
       class MultilineBlockChain < Cop
-        MSG = 'Avoid multi-line chains of blocks.'
+        MSG = 'Avoid multi-line chains of blocks.'.freeze
 
         def on_block(node)
           method, _args, _body = *node
@@ -31,7 +32,7 @@ module RuboCop
             range =
               Parser::Source::Range.new(end_kw_loc.source_buffer,
                                         end_kw_loc.begin_pos,
-                                        method.loc.expression.end_pos)
+                                        method.source_range.end_pos)
             add_offense(nil, range)
             # Done. If there are more blocks in the chain, they will be
             # found by subsequent calls to on_block.

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -36,9 +37,10 @@ module RuboCop
       #     bar(i)
       #   }
       class MultilineBlockLayout < Cop
-        MSG = 'Block body expression is on the same line as the block start.'
+        MSG = 'Block body expression is on the same line as ' \
+              'the block start.'.freeze
         ARG_MSG = 'Block argument expression is not on the same line as the ' \
-                  'block start.'
+                  'block start.'.freeze
 
         def on_block(node)
           end_loc = node.loc.end
@@ -64,7 +66,7 @@ module RuboCop
         end
 
         def add_offense_for_expression(node, expr, msg)
-          expression = expr.loc.expression
+          expression = expr.source_range
           range = Parser::Source::Range.new(expression.source_buffer,
                                             expression.begin_pos,
                                             expression.end_pos)
@@ -78,7 +80,7 @@ module RuboCop
             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
+              expr_before_body = args.source_range.end
             end
 
             return unless block_body
@@ -92,11 +94,11 @@ module RuboCop
 
         def autocorrect_arguments(corrector, node, args, block_body)
           end_pos = if block_body
-                      block_body.loc.expression.begin_pos
+                      block_body.source_range.begin_pos
                     else
                       node.loc.end.begin.begin_pos - 1
                     end
-          range = Parser::Source::Range.new(args.loc.expression.source_buffer,
+          range = Parser::Source::Range.new(args.source_range.source_buffer,
                                             node.loc.begin.end.begin_pos,
                                             end_pos)
           corrector.replace(range, " |#{block_arg_string(args)}|")
@@ -109,14 +111,14 @@ module RuboCop
                          block_body
                        end
 
-          block_start_col = node.loc.expression.column
+          block_start_col = node.source_range.column
 
-          corrector.insert_before(first_node.loc.expression,
+          corrector.insert_before(first_node.source_range,
                                   "\n  #{' ' * block_start_col}")
         end
 
         def block_arg_string(args)
-          args.children.map { |a| a.loc.expression.source }.join(', ')
+          args.children.map(&:source).join(', ')
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop

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

@@ -0,0 +1,137 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks the indentation of the method name part in method calls
+      # that span more than one line.
+      #
+      # @example
+      #   # bad
+      #   while a
+      #   .b
+      #     something
+      #   end
+      #
+      #   # good, EnforcedStyle: aligned
+      #   while a
+      #         .b
+      #     something
+      #   end
+      #
+      #   # good, EnforcedStyle: aligned
+      #   Thing.a
+      #        .b
+      #        .c
+      #
+      #   # good, EnforcedStyle: indented
+      #   while a
+      #       .b
+      #     something
+      #   end
+      class MultilineMethodCallIndentation < Cop
+        include ConfigurableEnforcedStyle
+        include AutocorrectAlignment
+        include MultilineExpressionIndentation
+
+        def validate_config
+          if style == :aligned && cop_config['IndentationWidth']
+            fail ValidationError, 'The `Style/MultilineMethodCallIndentation`' \
+                                  ' cop only accepts an `IndentationWidth` ' \
+                                  'configuration parameter when ' \
+                                  '`EnforcedStyle` is `indented`.'
+          end
+        end
+
+        private
+
+        def relevant_node?(send_node)
+          send_node.loc.dot # Only check method calls with dot operator
+        end
+
+        def offending_range(node, lhs, rhs, given_style)
+          return false unless begins_its_line?(rhs)
+          return false if not_for_this_cop?(node)
+
+          @base = alignment_base(node, rhs, given_style)
+          correct_column = if @base
+                             @base.column
+                           else
+                             indentation(lhs) + correct_indentation(node)
+                           end
+          @column_delta = correct_column - rhs.column
+          rhs if @column_delta != 0
+        end
+
+        def message(node, lhs, rhs)
+          what = operation_description(node, rhs)
+          if @base
+            "Align `#{rhs.source}` with `#{@base.source[/[^\n]*/]}` on " \
+              "line #{@base.line}."
+          else
+            used_indentation = rhs.column - indentation(lhs)
+            "Use #{correct_indentation(node)} (not #{used_indentation}) " \
+              "spaces for indenting #{what} spanning multiple lines."
+          end
+        end
+
+        def alignment_base(node, rhs, given_style)
+          return nil unless given_style == :aligned
+
+          semantic_alignment_base(node, rhs) ||
+            syntactic_alignment_base(node, rhs)
+        end
+
+        def syntactic_alignment_base(lhs, rhs)
+          # a if b
+          #      .c
+          n = kw_node_with_special_indentation(lhs)
+          if n
+            case n.type
+            when :if, :while, :until then expression, = *n
+            when :for                then _, expression, = *n
+            when :return             then expression, = *n
+            end
+            return expression.source_range
+          end
+
+          # a = b
+          #     .c
+          n = part_of_assignment_rhs(lhs, rhs)
+          return assignment_rhs(n).source_range if n
+
+          # a + b
+          #     .c
+          n = operation_rhs(lhs)
+          return n.source_range if n
+        end
+
+        # a.b
+        #  .c
+        def semantic_alignment_base(node, rhs)
+          return nil unless rhs.source.start_with?('.')
+          return nil if argument_in_method_call(node)
+
+          node, = *node while node.send_type? && node.loc.dot ||
+                              node.block_type?
+          return nil unless node.parent.send_type?
+
+          first_send = node.parent
+          return nil if first_send.loc.dot.line != first_send.loc.line
+
+          first_send.loc.dot.join(first_send.loc.selector)
+        end
+
+        def operation_rhs(node)
+          receiver, = *node
+          receiver.each_ancestor.select(&:send_type?).each do |a|
+            _, method, args = *a
+            return args if operator?(method) && within_node?(receiver, args)
+          end
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,10 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # This cops checks the indentation of the right hand side operand in
+      # This cop checks the indentation of the right hand side operand in
       # binary operations that span more than one line.
       #
       # @example
@@ -15,6 +16,7 @@ module RuboCop
       class MultilineOperationIndentation < Cop
         include ConfigurableEnforcedStyle
         include AutocorrectAlignment
+        include MultilineExpressionIndentation
 
         def on_and(node)
           check_and_or(node)
@@ -24,41 +26,25 @@ module RuboCop
           check_and_or(node)
         end
 
-        def on_send(node)
-          receiver, method_name, *_args = *node
-          return unless receiver
-          return if method_name == :[] # Don't check parameters inside [].
-
-          lhs = left_hand_side(receiver)
-          rhs = right_hand_side(node)
-          range = offending_range(node, lhs, rhs, style)
-          check(range, node, lhs, rhs)
+        def validate_config
+          if style == :aligned && cop_config['IndentationWidth']
+            fail ValidationError, 'The `Style/MultilineOperationIndentation`' \
+                                  ' cop only accepts an `IndentationWidth` ' \
+                                  'configuration parameter when ' \
+                                  '`EnforcedStyle` is `indented`.'
+          end
         end
 
         private
 
-        def check_and_or(node)
-          lhs, rhs = *node
-          range = offending_range(node, lhs, rhs.loc.expression, style)
-          check(range, node, lhs, rhs.loc.expression)
-        end
-
-        def check(range, node, lhs, rhs)
-          if range
-            incorrect_style_detected(range, node, lhs, rhs)
-          else
-            correct_style_detected
-          end
+        def relevant_node?(node)
+          !node.loc.dot # Don't check method calls with dot operator.
         end
 
-        def incorrect_style_detected(range, node, lhs, rhs)
-          add_offense(range, range, message(node, lhs, rhs)) do
-            if offending_range(node, lhs, rhs, alternative_style)
-              unrecognized_style_detected
-            else
-              opposite_style_detected
-            end
-          end
+        def check_and_or(node)
+          lhs, rhs = *node
+          range = offending_range(node, lhs, rhs.source_range, style)
+          check(range, node, lhs, rhs.source_range)
         end
 
         def offending_range(node, lhs, rhs, given_style)
@@ -66,7 +52,7 @@ module RuboCop
           return false if lhs.loc.line == rhs.line # Needed for unary op.
           return false if not_for_this_cop?(node)
 
-          correct_column = if should_align?(node, given_style)
+          correct_column = if should_align?(node, rhs, given_style)
                              lhs.loc.column
                            else
                              indentation(lhs) + correct_indentation(node)
@@ -75,9 +61,15 @@ module RuboCop
           rhs if @column_delta != 0
         end
 
+        def should_align?(node, rhs, given_style)
+          given_style == :aligned && (kw_node_with_special_indentation(node) ||
+                                      part_of_assignment_rhs(node, rhs) ||
+                                      argument_in_method_call(node))
+        end
+
         def message(node, lhs, rhs)
-          what = operation_description(node)
-          if should_align?(node, style)
+          what = operation_description(node, rhs)
+          if should_align?(node, rhs, style)
             "Align the operands of #{what} spanning multiple lines."
           else
             used_indentation = rhs.column - indentation(lhs)
@@ -85,108 +77,6 @@ module RuboCop
               "spaces for indenting #{what} spanning multiple lines."
           end
         end
-
-        def indentation(node)
-          node.loc.expression.source_line =~ /\S/
-        end
-
-        def operation_description(node)
-          ancestor = kw_node_with_special_indentation(node)
-          if ancestor
-            kw = ancestor.loc.keyword.source
-            kind = kw == 'for' ? 'collection' : 'condition'
-            article = kw =~ /^[iu]/ ? 'an' : 'a'
-            "a #{kind} in #{article} `#{kw}` statement"
-          else
-            'an expression' + (assignment_rhs?(node) ? ' in an assignment' : '')
-          end
-        end
-
-        # In a chain of method calls, we regard the top send node as the base
-        # for indentation of all lines following the first. For example:
-        # a.
-        #   b c { block }.            <-- b is indented relative to a
-        #   d                         <-- d is indented relative to a
-        def left_hand_side(receiver)
-          lhs = receiver
-          while lhs.parent && lhs.parent.type == :send
-            _receiver, method_name, *_args = *lhs.parent
-            break if operator?(method_name)
-            lhs = lhs.parent
-          end
-          lhs
-        end
-
-        def right_hand_side(send_node)
-          _, method_name, *args = *send_node
-          if operator?(method_name) && args.any?
-            args.first.loc.expression
-          else
-            dot = send_node.loc.dot
-            selector = send_node.loc.selector
-            if dot && selector && dot.line == selector.line
-              dot.join(selector)
-            elsif selector
-              selector
-            elsif dot.line == send_node.loc.begin.line
-              # lambda.(args)
-              dot.join(send_node.loc.begin)
-            end
-          end
-        end
-
-        def correct_indentation(node)
-          multiplier = kw_node_with_special_indentation(node) ? 2 : 1
-          configured_indentation_width * multiplier
-        end
-
-        def should_align?(node, given_style)
-          given_style == :aligned && (kw_node_with_special_indentation(node) ||
-                                      assignment_rhs?(node))
-        end
-
-        def kw_node_with_special_indentation(node)
-          node.each_ancestor.find do |a|
-            next unless a.loc.respond_to?(:keyword)
-
-            case a.type
-            when :if, :while, :until then condition, = *a
-            when :for                then _, collection, = *a
-            end
-
-            if condition || collection
-              within_node?(node, condition || collection)
-            end
-          end
-        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
-
-        def not_for_this_cop?(node)
-          node.each_ancestor.any? do |ancestor|
-            grouped_expression?(ancestor) ||
-              inside_arg_list_parentheses?(node, ancestor)
-          end
-        end
-
-        def grouped_expression?(node)
-          node.type == :begin && node.loc.respond_to?(:begin) && node.loc.begin
-        end
-
-        def inside_arg_list_parentheses?(node, ancestor)
-          a = ancestor.loc
-          return false unless ancestor.type == :send && a.begin &&
-                              a.begin.is?('(')
-          n = node.loc.expression
-          n.begin_pos > a.begin.begin_pos && n.end_pos < a.end.end_pos
-        end
       end
     end
   end