rubocop 0.42.0 → 0.52.1

data/lib/rubocop/cop/{style → layout}/multiline_assignment_layout.rb

@@ -1,36 +1,36 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks whether the multiline assignments have a newline
       # after the assignment operator.
       #
-      # @example
-      #   # bad (with EnforcedStyle set to new_line)
+      # @example EnforcedStyle: new_line (default)
+      #   # bad
       #   foo = if expression
       #     'bar'
       #   end
       #
-      #   # good (with EnforcedStyle set to same_line)
-      #   foo = if expression
-      #     'bar'
-      #   end
-      #
-      #   # good (with EnforcedStyle set to new_line)
+      #   # good
       #   foo =
       #     if expression
       #       'bar'
       #     end
       #
-      #   # good (with EnforcedStyle set to new_line)
+      #   # good
       #   foo =
       #     begin
       #       compute
       #     rescue => e
       #       nil
       #     end
+      #
+      # @example EnforcedStyle: same_line
+      #   # good
+      #   foo = if expression
+      #     'bar'
+      #   end
       class MultilineAssignmentLayout < Cop
         include CheckAssignment
         include ConfigurableEnforcedStyle
@@ -44,7 +44,7 @@ module RuboCop
         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
+          return if rhs.first_line == rhs.last_line
 
           case style
           when :new_line
@@ -55,15 +55,15 @@ module RuboCop
         end
 
         def check_new_line_offense(node, rhs)
-          return unless node.loc.operator.line == rhs.loc.line
+          return unless node.loc.operator.line == rhs.first_line
 
-          add_offense(node, :expression, NEW_LINE_OFFENSE)
+          add_offense(node, message: NEW_LINE_OFFENSE)
         end
 
         def check_same_line_offense(node, rhs)
-          return unless node.loc.operator.line != rhs.loc.line
+          return unless node.loc.operator.line != rhs.first_line
 
-          add_offense(node, :expression, SAME_LINE_OFFENSE)
+          add_offense(node, message: SAME_LINE_OFFENSE)
         end
 
         def autocorrect(node)
@@ -71,11 +71,8 @@ module RuboCop
           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
-            )
+            range = range_between(node.loc.operator.end_pos,
+                                  extract_rhs(node).source_range.begin_pos)
 
             ->(corrector) { corrector.replace(range, ' ') }
           end

data/lib/rubocop/cop/{style → layout}/multiline_block_layout.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks whether the multiline do end blocks have a newline
       # 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.
@@ -43,65 +42,60 @@ module RuboCop
                   'block start.'.freeze
 
         def on_block(node)
-          end_loc = node.loc.end
-          do_loc = node.loc.begin # Actually it's either do or {.
-          return if do_loc.line == end_loc.line # One-liner, no newline needed.
-
-          # A block node has three children: the block start,
-          # the arguments, and the expression. We care if the block start
-          # with arguments and the expression start on the same line.
-          _block_start, args, last_expression = node.children
-
-          unless args.children.empty?
-            if do_loc.line != args.loc.last_line
-              add_offense_for_expression(node, args, ARG_MSG)
-            end
-          end
+          return if node.single_line?
 
-          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
+          unless args_on_beginning_line?(node)
+            add_offense_for_expression(node, node.arguments, ARG_MSG)
+          end
 
-        def add_offense_for_expression(node, expr, msg)
-          expression = expr.source_range
-          range = Parser::Source::Range.new(expression.source_buffer,
-                                            expression.begin_pos,
-                                            expression.end_pos)
+          return unless node.body && node.loc.begin.line == node.body.first_line
 
-          add_offense(node, range, msg)
+          add_offense_for_expression(node, node.body, MSG)
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            _method, args, block_body = *node
-            unless args.children.empty? || args.loc.last_line == node.loc.line
-              autocorrect_arguments(corrector, node, args)
-              expr_before_body = args.source_range.end
+            unless args_on_beginning_line?(node)
+              autocorrect_arguments(corrector, node)
+              expr_before_body = node.arguments.source_range.end
             end
 
-            return unless block_body
+            return unless node.body
 
             expr_before_body ||= node.loc.begin
-            if expr_before_body.line == block_body.loc.line
-              autocorrect_body(corrector, node, block_body)
+
+            if expr_before_body.line == node.body.first_line
+              autocorrect_body(corrector, node, node.body)
             end
           end
         end
 
-        def autocorrect_arguments(corrector, node, args)
-          end_pos =
-            range_with_surrounding_space(args.source_range, :right, false)
-            .end_pos
-          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)}|")
+        private
+
+        def args_on_beginning_line?(node)
+          !node.arguments? ||
+            node.loc.begin.line == node.arguments.loc.last_line
+        end
+
+        def add_offense_for_expression(node, expr, msg)
+          expression = expr.source_range
+          range = range_between(expression.begin_pos, expression.end_pos)
+
+          add_offense(node, location: range, message: msg)
+        end
+
+        def autocorrect_arguments(corrector, node)
+          end_pos = range_with_surrounding_space(
+            range: node.arguments.source_range,
+            side: :right,
+            newlines: false
+          ).end_pos
+          range = range_between(node.loc.begin.end.begin_pos, end_pos)
+          corrector.replace(range, " |#{block_arg_string(node.arguments)}|")
         end
 
         def autocorrect_body(corrector, node, block_body)
-          first_node = if block_body.type == :begin
+          first_node = if block_body.begin_type?
                          block_body.children.first
                        else
                          block_body

data/lib/rubocop/cop/{style → layout}/multiline_hash_brace_layout.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks that the closing brace in a hash literal is either
       # on the same line as the last hash element, or a new line.
       #
@@ -27,35 +26,68 @@ module RuboCop
       # The closing brace of a multi-line hash literal must be on the same
       # line as the last element of the hash.
       #
-      # @example
+      # @example EnforcedStyle: symmetrical (default)
       #
-      #     # symmetrical: bad
-      #     # new_line: good
-      #     # same_line: bad
+      #     # bad
       #     { a: 1,
       #       b: 2
       #     }
+      #     # bad
+      #     {
+      #       a: 1,
+      #       b: 2 }
+      #
+      #     # good
+      #     { a: 1,
+      #       b: 2 }
+      #
+      #     # good
+      #     {
+      #       a: 1,
+      #       b: 2
+      #     }
       #
-      #     # symmetrical: bad
-      #     # new_line: bad
-      #     # same_line: good
+      # @example EnforcedStyle: new_line
+      #     # bad
       #     {
       #       a: 1,
       #       b: 2 }
       #
-      #     # symmetrical: good
-      #     # new_line: bad
-      #     # same_line: good
+      #     # bad
       #     { a: 1,
       #       b: 2 }
       #
-      #     # symmetrical: good
-      #     # new_line: good
-      #     # same_line: bad
+      #     # good
+      #     { a: 1,
+      #       b: 2
+      #     }
+      #
+      #     # good
       #     {
       #       a: 1,
       #       b: 2
       #     }
+      #
+      # @example EnforcedStyle: same_line
+      #     # bad
+      #     { a: 1,
+      #       b: 2
+      #     }
+      #
+      #     # bad
+      #     {
+      #       a: 1,
+      #       b: 2
+      #     }
+      #
+      #     # good
+      #     {
+      #       a: 1,
+      #       b: 2 }
+      #
+      #     # good
+      #     { a: 1,
+      #       b: 2 }
       class MultilineHashBraceLayout < Cop
         include MultilineLiteralBraceLayout
 
@@ -73,9 +105,17 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing hash brace must be on the same ' \
           'line as the last hash element.'.freeze
 
+        def self.autocorrect_incompatible_with
+          [Style::BracesAroundHashParameters]
+        end
+
         def on_hash(node)
           check_brace_layout(node)
         end
+
+        def autocorrect(node)
+          MultilineLiteralBraceCorrector.correct(processed_source, node)
+        end
       end
     end
   end

data/lib/rubocop/cop/{style → layout}/multiline_method_call_brace_layout.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks that the closing brace in a method call is either
       # on the same line as the last method argument, or a new line.
       #
@@ -77,12 +76,24 @@ module RuboCop
           check_brace_layout(node)
         end
 
+        def autocorrect(node)
+          MultilineLiteralBraceCorrector.correct(processed_source, node)
+        end
+
         private
 
         def children(node)
-          _receiver, _method_name, *args = *node
+          node.arguments
+        end
+
+        def ignored_literal?(node)
+          single_line_ignoring_receiver?(node) || super
+        end
+
+        def single_line_ignoring_receiver?(node)
+          return false unless node.loc.begin && node.loc.end
 
-          args
+          node.loc.begin.line == node.loc.end.line
         end
       end
     end

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

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks the indentation of the method name part in method calls
+      # that span more than one line.
+      #
+      # @example EnforcedStyle: aligned
+      #   # bad
+      #   while myvariable
+      #   .b
+      #     # do something
+      #   end
+      #
+      #   # good
+      #   while myvariable
+      #         .b
+      #     # do something
+      #   end
+      #
+      #   # good
+      #   Thing.a
+      #        .b
+      #        .c
+      #
+      # @example EnforcedStyle: indented
+      #   # good
+      #   while myvariable
+      #     .b
+      #
+      #     # do something
+      #   end
+      #
+      # @example EnforcedStyle: indented_relative_to_receiver
+      #   # good
+      #   while myvariable
+      #           .a
+      #           .b
+      #
+      #     # do something
+      #   end
+      #
+      #   # good
+      #   myvariable = Thing
+      #                  .a
+      #                  .b
+      #                  .c
+      class MultilineMethodCallIndentation < Cop
+        include ConfigurableEnforcedStyle
+        include Alignment
+        include MultilineExpressionIndentation
+
+        def validate_config
+          return unless style == :aligned && cop_config['IndentationWidth']
+
+          raise ValidationError,
+                'The `Layout/MultilineMethodCallIndentation`' \
+                ' cop only accepts an `IndentationWidth` ' \
+                'configuration parameter when ' \
+                '`EnforcedStyle` is `indented`.'
+        end
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        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 + extra_indentation(given_style)
+                           else
+                             indentation(lhs) + correct_indentation(node)
+                           end
+          @column_delta = correct_column - rhs.column
+          rhs if @column_delta.nonzero?
+        end
+
+        def extra_indentation(given_style)
+          if given_style == :indented_relative_to_receiver
+            configured_indentation_width
+          else
+            0
+          end
+        end
+
+        def message(node, lhs, rhs)
+          if should_indent_relative_to_receiver?
+            relative_to_receiver_message(rhs)
+          elsif should_align_with_base?
+            align_with_base_message(rhs)
+          else
+            no_base_message(lhs, rhs, node)
+          end
+        end
+
+        def should_indent_relative_to_receiver?
+          @base && style == :indented_relative_to_receiver
+        end
+
+        def should_align_with_base?
+          @base && style != :indented_relative_to_receiver
+        end
+
+        def relative_to_receiver_message(rhs)
+          "Indent `#{rhs.source}` #{configured_indentation_width} spaces " \
+            "more than `#{base_source}` on line #{@base.line}."
+        end
+
+        def align_with_base_message(rhs)
+          "Align `#{rhs.source}` with `#{base_source}` on line #{@base.line}."
+        end
+
+        def base_source
+          @base.source[/[^\n]*/]
+        end
+
+        def no_base_message(lhs, rhs, node)
+          used_indentation = rhs.column - indentation(lhs)
+          what = operation_description(node, rhs)
+
+          "Use #{correct_indentation(node)} (not #{used_indentation}) " \
+            "spaces for indenting #{what} spanning multiple lines."
+        end
+
+        def alignment_base(node, rhs, given_style)
+          case given_style
+          when :aligned
+            semantic_alignment_base(node, rhs) ||
+              syntactic_alignment_base(node, rhs)
+          when :indented
+            nil
+          when :indented_relative_to_receiver
+            receiver_alignment_base(node)
+          end
+        end
+
+        def syntactic_alignment_base(lhs, rhs)
+          # a if b
+          #      .c
+          kw_node_with_special_indentation(lhs) do |base|
+            return indented_keyword_expression(base).source_range
+          end
+
+          # a = b
+          #     .c
+          part_of_assignment_rhs(lhs, rhs) do |base|
+            return assignment_rhs(base).source_range
+          end
+
+          # a + b
+          #     .c
+          operation_rhs(lhs) do |base|
+            return base.source_range
+          end
+        end
+
+        # a.b
+        #  .c
+        def semantic_alignment_base(node, rhs)
+          return unless rhs.source.start_with?('.')
+
+          node = semantic_alignment_node(node)
+          return unless node && node.loc.selector
+
+          node.loc.dot.join(node.loc.selector)
+        end
+
+        # a
+        #   .b
+        #   .c
+        def receiver_alignment_base(node)
+          node = node.receiver while node.receiver
+          node = node.parent
+          node = node.parent until node.loc.dot
+
+          node.receiver.source_range if node
+        end
+
+        def semantic_alignment_node(node)
+          return if argument_in_method_call(node, :with_parentheses)
+
+          # descend to root of method chain
+          node = node.receiver while node.receiver
+          # ascend to first call which has a dot
+          node = node.parent
+          node = node.parent until node.loc.dot
+
+          return if node.loc.dot.line != node.first_line
+          node
+        end
+
+        def operation_rhs(node)
+          receiver, = *node
+
+          operation_rhs = receiver.each_ancestor(:send).find do |rhs|
+            operator_rhs?(rhs, receiver)
+          end
+
+          return unless operation_rhs
+
+          yield operation_rhs.first_argument
+        end
+
+        def operator_rhs?(node, receiver)
+          node.operator_method? && node.arguments? &&
+            within_node?(receiver, node.first_argument)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/{style → layout}/multiline_method_definition_brace_layout.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks that the closing brace in a method definition is either
       # on the same line as the last method parameter, or a new line.
       #
@@ -35,6 +34,7 @@ module RuboCop
       #     def foo(a,
       #       b
       #     )
+      #     end
       #
       #     # symmetrical: bad
       #     # new_line: bad
@@ -42,12 +42,14 @@ module RuboCop
       #     def foo(
       #       a,
       #       b)
+      #     end
       #
       #     # symmetrical: good
       #     # new_line: bad
       #     # same_line: good
       #     def foo(a,
       #       b)
+      #     end
       #
       #     # symmetrical: good
       #     # new_line: good
@@ -56,8 +58,8 @@ module RuboCop
       #       a,
       #       b
       #     )
+      #     end
       class MultilineMethodDefinitionBraceLayout < Cop
-        include OnMethodDef
         include MultilineLiteralBraceLayout
 
         SAME_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
@@ -74,8 +76,13 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing method definition brace must be ' \
           'on the same line as the last parameter.'.freeze
 
-        def on_method_def(_node, _method_name, args, _body)
-          check_brace_layout(args)
+        def on_def(node)
+          check_brace_layout(node.arguments)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          MultilineLiteralBraceCorrector.correct(processed_source, node)
         end
       end
     end