rubocop 1.31.1 → 1.51.0

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

@@ -20,6 +20,29 @@ module RuboCop
       #     b: 2,
       #     c: 3
       #   }
+      #
+      #   # good
+      #   {
+      #     a: 1,
+      #     b: {
+      #       c: 3,
+      #     }
+      #   }
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   { a: 1, b: {
+      #     c: 3,
+      #   }}
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # good
+      #   { a: 1, b: {
+      #     c: 3,
+      #   }}
+      #
       class MultilineHashKeyLineBreaks < Base
         include MultilineElementLineBreaks
         extend AutoCorrector
@@ -31,8 +54,9 @@ module RuboCop
           # braces like {foo: 1}. That is, not a kwargs hashes.
           # Style/MultilineMethodArgumentLineBreaks handles those.
           return unless starts_with_curly_brace?(node)
+          return unless node.loc.begin
 
-          check_line_breaks(node, node.children) if node.loc.begin
+          check_line_breaks(node, node.children, ignore_last: ignore_last_element?)
         end
 
         private
@@ -40,6 +64,10 @@ module RuboCop
         def starts_with_curly_brace?(node)
           node.loc.begin
         end
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
+        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module RuboCop
       # Ensures that each argument in a multi-line method call
       # starts on a separate line.
       #
-      # NOTE: this cop does not move the first argument, if you want that to
+      # NOTE: This cop does not move the first argument, if you want that to
       # be on a separate line, see `Layout/FirstMethodArgumentLineBreak`.
       #
       # @example
@@ -16,12 +16,43 @@ module RuboCop
       #     c
       #   )
       #
+      #   # bad
+      #   foo(a, b, {
+      #     foo: "bar",
+      #   })
+      #
       #   # good
       #   foo(
       #     a,
       #     b,
       #     c
       #   )
+      #
+      #   # good
+      #   foo(a, b, c)
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # good
+      #   foo(
+      #     a,
+      #     b,
+      #     {
+      #       foo: "bar",
+      #     }
+      #   )
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # good
+      #   foo(
+      #     a,
+      #     b,
+      #     {
+      #       foo: "bar",
+      #     }
+      #   )
+      #
       class MultilineMethodArgumentLineBreaks < Base
         include MultilineElementLineBreaks
         extend AutoCorrector
@@ -42,7 +73,13 @@ module RuboCop
           last_arg = args.last
           args = args[0...-1] + last_arg.children if last_arg&.hash_type? && !last_arg&.braces?
 
-          check_line_breaks(node, args)
+          check_line_breaks(node, args, ignore_last: ignore_last_element?)
+        end
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
         end
       end
     end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Ensures that each parameter in a multi-line method definition
+      # starts on a separate line.
+      #
+      # NOTE: This cop does not move the first argument, if you want that to
+      # be on a separate line, see `Layout/FirstMethodParameterLineBreak`.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo(a, b,
+      #     c
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b,
+      #     c
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b = {
+      #       foo: "bar",
+      #     }
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(a, b, c)
+      #   end
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   def foo(a, b = {
+      #     foo: "bar",
+      #   })
+      #   end
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # good
+      #   def foo(a, b = {
+      #     foo: "bar",
+      #   })
+      #   end
+      #
+      class MultilineMethodParameterLineBreaks < Base
+        include MultilineElementLineBreaks
+        extend AutoCorrector
+
+        MSG = 'Each parameter in a multi-line method definition must start on a separate line.'
+
+        def on_def(node)
+          return if node.arguments.empty?
+
+          check_line_breaks(node, node.arguments, ignore_last: ignore_last_element?)
+        end
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
+        end
+      end
+    end
+  end
+end

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

@@ -50,9 +50,9 @@ module RuboCop
 
         def on_send(node)
           # Include "the whole expression".
-          node = node.parent while convertible_block?(node) ||
-                                   node.parent.is_a?(RuboCop::AST::BinaryOperatorNode) ||
-                                   node.parent&.send_type?
+          node = node.parent while node.parent&.send_type? ||
+                                   convertible_block?(node) ||
+                                   node.parent.is_a?(RuboCop::AST::BinaryOperatorNode)
 
           return unless offense?(node) && !part_of_ignored_node?(node)
 
@@ -69,26 +69,25 @@ module RuboCop
 
         def register_offense(node)
           add_offense(node) do |corrector|
-            corrector.replace(node.source_range, to_single_line(node.source).strip)
+            corrector.replace(node, to_single_line(node.source).strip)
           end
           ignore_node(node)
         end
 
         def offense?(node)
-          return false if configured_to_not_be_inspected?(node)
-
-          node.multiline? && !too_long?(node) && suitable_as_single_line?(node)
+          node.multiline? && !too_long?(node) && suitable_as_single_line?(node) &&
+            !configured_to_not_be_inspected?(node)
         end
 
         def configured_to_not_be_inspected?(node)
           return true if other_cop_takes_precedence?(node)
 
           !cop_config['InspectBlocks'] && (node.block_type? ||
-                                           node.each_descendant(:block).any?(&:multiline?))
+                                           any_descendant?(node, :block, &:multiline?))
         end
 
         def other_cop_takes_precedence?(node)
-          single_line_block_chain_enabled? && node.each_descendant(:block).any? do |block_node|
+          single_line_block_chain_enabled? && any_descendant?(node, :block) do |block_node|
             block_node.parent.send_type? && block_node.parent.loc.dot && !block_node.multiline?
           end
         end
@@ -101,7 +100,7 @@ module RuboCop
           !comment_within?(node) &&
             node.each_descendant(:if, :case, :kwbegin, :def).none? &&
             node.each_descendant(:dstr, :str).none?(&:heredoc?) &&
-            node.each_descendant(:begin).none? { |b| b.first_line != b.last_line }
+            node.each_descendant(:begin).none? { |b| !b.single_line? }
         end
 
         def convertible_block?(node)

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

@@ -102,7 +102,7 @@ module RuboCop
               node.loc.name
             when :masgn
               mlhs_node, = *node
-              mlhs_node.loc.expression
+              mlhs_node.source_range
             else
               # It is a wrapper with access modifier.
               node.child_nodes.first.loc.name
@@ -196,7 +196,7 @@ module RuboCop
           if begin_end_alignment_style == 'start_of_line'
             start_line_range(alignment_node)
           else
-            alignment_node.loc.expression
+            alignment_node.source_range
           end
         end
 

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

@@ -29,7 +29,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           arguments = node.arguments
 
           return unless node.arguments? && pipes?(arguments)

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

@@ -41,7 +41,7 @@ module RuboCop
           check(node, [:operator].freeze) if node.keyword?
         end
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           check(node, %i[begin end].freeze)
         end
 
@@ -241,7 +241,7 @@ module RuboCop
         end
 
         def accept_namespace_operator?(range)
-          ACCEPT_NAMESPACE_OPERATOR == range.source
+          range.source == ACCEPT_NAMESPACE_OPERATOR
         end
 
         def safe_navigation_call?(range, pos)
@@ -256,7 +256,7 @@ module RuboCop
           # regular dotted method calls bind more tightly than operators
           # so we need to climb up the AST past them
           node.each_ancestor do |ancestor|
-            return true if ancestor.and_type? || ancestor.or_type?
+            return true if ancestor.and_type? || ancestor.or_type? || ancestor.range_type?
             return false unless ancestor.send_type?
             return true if ancestor.operator_method?
           end

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

@@ -177,7 +177,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, range)
-          if /\*\*/.match?(range.source) && !space_around_exponent_operator?
+          if range.source.include?('**') && !space_around_exponent_operator?
             corrector.replace(range, '**')
           elsif range.source.end_with?("\n")
             corrector.replace(range, " #{range.source.strip}\n")

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

@@ -76,6 +76,8 @@ module RuboCop
           end
         end
 
+        alias on_numblock on_block
+
         private
 
         def check_empty(left_brace, space_plus_brace, used_style)

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

@@ -34,6 +34,7 @@ module RuboCop
 
         def on_send(node)
           return unless regular_method_call_with_arguments?(node)
+          return if node.parenthesized?
 
           first_arg = node.first_argument.source_range
           first_arg_with_space = range_with_surrounding_space(first_arg, side: :left)
@@ -52,7 +53,6 @@ module RuboCop
         end
 
         def expect_params_after_method_name?(node)
-          return false if node.parenthesized?
           return true if no_space_between_method_name_and_first_argument?(node)
 
           first_arg = node.first_argument

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

@@ -64,8 +64,8 @@ module RuboCop
 
         def range_of_offense(node)
           range_between(
-            node.parent.loc.expression.begin_pos,
-            node.parent.arguments.loc.expression.end_pos
+            node.parent.source_range.begin_pos,
+            node.parent.arguments.source_range.end_pos
           )
         end
 

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

@@ -78,8 +78,11 @@ module RuboCop
         def on_array(node)
           return unless node.square_brackets?
 
-          left, right = array_brackets(node)
-          return empty_offenses(node, left, right, EMPTY_MSG) if empty_brackets?(left, right)
+          tokens, left, right = array_brackets(node)
+
+          if empty_brackets?(left, right, tokens: tokens)
+            return empty_offenses(node, left, right, EMPTY_MSG)
+          end
 
           start_ok = next_to_newline?(node, left)
           end_ok = node.single_line? ? false : end_has_own_line?(right)
@@ -90,9 +93,9 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          left, right = array_brackets(node)
+          tokens, left, right = array_brackets(node)
 
-          if empty_brackets?(left, right)
+          if empty_brackets?(left, right, tokens: tokens)
             SpaceCorrector.empty_corrections(processed_source, corrector, empty_config, left, right)
           elsif style == :no_space
             SpaceCorrector.remove_space(processed_source, corrector, left, right)
@@ -104,15 +107,12 @@ module RuboCop
         end
 
         def array_brackets(node)
-          [left_array_bracket(node), right_array_bracket(node)]
-        end
+          tokens = processed_source.tokens_within(node)
 
-        def left_array_bracket(node)
-          processed_source.tokens_within(node).find(&:left_array_bracket?)
-        end
+          left = tokens.find(&:left_array_bracket?)
+          right = tokens.reverse_each.find(&:right_bracket?)
 
-        def right_array_bracket(node)
-          processed_source.tokens_within(node).reverse.find(&:right_bracket?)
+          [tokens, left, right]
         end
 
         def empty_config
@@ -169,19 +169,20 @@ module RuboCop
 
         def qualifies_for_compact?(node, token, side: :right)
           if side == :right
-            multi_dimensional_array?(node, token) && !next_to_bracket?(token)
+            multi_dimensional_array?(node, token) && token.space_before?
           else
-            multi_dimensional_array?(node, token, side: :left) &&
-              !next_to_bracket?(token, side: :left)
+            multi_dimensional_array?(node, token, side: :left) && token.space_after?
           end
         end
 
         def multi_dimensional_array?(node, token, side: :right)
-          i = index_for(node, token)
+          offset = side == :right ? -1 : +1
+          i = index_for(node, token) + offset
+          i += offset while processed_source.tokens_within(node)[i].new_line?
           if side == :right
-            processed_source.tokens_within(node)[i - 1].right_bracket?
+            processed_source.tokens_within(node)[i].right_bracket?
           else
-            processed_source.tokens_within(node)[i + 1].left_array_bracket?
+            processed_source.tokens_within(node)[i].left_array_bracket?
           end
         end
 
@@ -200,12 +201,13 @@ module RuboCop
         end
 
         def compact_corrections(corrector, node, left, right)
-          if qualifies_for_compact?(node, left, side: :left)
+          if multi_dimensional_array?(node, left, side: :left)
             compact(corrector, left, :right)
           elsif !left.space_after?
             corrector.insert_after(left.pos, ' ')
           end
-          if qualifies_for_compact?(node, right)
+
+          if multi_dimensional_array?(node, right)
             compact(corrector, right, :left)
           elsif !right.space_before?
             corrector.insert_before(right.pos, ' ')
@@ -213,7 +215,7 @@ module RuboCop
         end
 
         def compact(corrector, bracket, side)
-          range = side_space_range(range: bracket.pos, side: side)
+          range = side_space_range(range: bracket.pos, side: side, include_newlines: true)
           corrector.remove(range)
         end
       end

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

@@ -6,6 +6,9 @@ module RuboCop
       # Checks for unnecessary additional spaces inside array percent literals
       # (i.e. %i/%w).
       #
+      # Note that blank percent literals (e.g. `%i( )`) are checked by
+      # `Layout/SpaceInsidePercentLiteralDelimiters`.
+      #
       # @example
       #
       #   # bad

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

@@ -131,7 +131,7 @@ module RuboCop
           args_delimiter = node.arguments.loc.begin if node.block_type? # Can be ( | or nil.
 
           check_left_brace(inner, node.loc.begin, args_delimiter)
-          check_right_brace(inner, node.loc.begin, node.loc.end, node.single_line?)
+          check_right_brace(node, inner, node.loc.begin, node.loc.end, node.single_line?)
         end
 
         def check_left_brace(inner, left_brace, args_delimiter)
@@ -142,14 +142,15 @@ module RuboCop
           end
         end
 
-        def check_right_brace(inner, left_brace, right_brace, single_line)
+        def check_right_brace(node, inner, left_brace, right_brace, single_line)
           if single_line && /\S$/.match?(inner)
             no_space(right_brace.begin_pos, right_brace.end_pos, 'Space missing inside }.')
           else
+            column = node.source_range.column
             return if multiline_block?(left_brace, right_brace) &&
-                      aligned_braces?(left_brace, right_brace)
+                      aligned_braces?(inner, right_brace, column)
 
-            space_inside_right_brace(right_brace)
+            space_inside_right_brace(inner, right_brace, column)
           end
         end
 
@@ -157,8 +158,12 @@ module RuboCop
           left_brace.first_line != right_brace.first_line
         end
 
-        def aligned_braces?(left_brace, right_brace)
-          left_brace.first_line == right_brace.last_column
+        def aligned_braces?(inner, right_brace, column)
+          column == right_brace.column || column == inner_last_space_count(inner)
+        end
+
+        def inner_last_space_count(inner)
+          inner.split("\n").last.count(' ')
         end
 
         def no_space_inside_left_brace(left_brace, args_delimiter)
@@ -197,10 +202,21 @@ module RuboCop
           args_delimiter&.is?('|')
         end
 
-        def space_inside_right_brace(right_brace)
+        def space_inside_right_brace(inner, right_brace, column)
           brace_with_space = range_with_surrounding_space(right_brace, side: :left)
-          space(brace_with_space.begin_pos, brace_with_space.end_pos - 1,
-                'Space inside } detected.')
+          begin_pos = brace_with_space.begin_pos
+          end_pos = brace_with_space.end_pos - 1
+
+          if brace_with_space.source.match?(/\R/)
+            begin_pos = end_pos - (right_brace.column - column)
+          end
+
+          if inner.end_with?(']')
+            end_pos -= 1
+            begin_pos = end_pos - (inner_last_space_count(inner) - column)
+          end
+
+          space(begin_pos, end_pos, 'Space inside } detected.')
         end
 
         def no_space(begin_pos, end_pos, msg)
@@ -220,6 +236,8 @@ module RuboCop
         end
 
         def offense(begin_pos, end_pos, msg, style_param = 'EnforcedStyle')
+          return if begin_pos > end_pos
+
           range = range_between(begin_pos, end_pos)
           add_offense(range, message: msg) do |corrector|
             case range.source

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

@@ -46,10 +46,13 @@ module RuboCop
       #   # bad
       #   foo = { }
       #   bar = {    }
+      #   baz = {
+      #   }
       #
       #   # good
       #   foo = {}
       #   bar = {}
+      #   baz = {}
       #
       # @example EnforcedStyleForEmptyBraces: space
       #   # The `space` EnforcedStyleForEmptyBraces style enforces that
@@ -60,8 +63,9 @@ module RuboCop
       #
       #   # good
       #   foo = { }
-      #   foo = {  }
-      #   foo = {     }
+      #   foo = {    }
+      #   foo = {
+      #   }
       #
       class SpaceInsideHashLiteralBraces < Base
         include SurroundingSpace
@@ -77,6 +81,7 @@ module RuboCop
 
           check(tokens[0], tokens[1])
           check(tokens[-2], tokens[-1]) if tokens.size > 2
+          check_whitespace_only_hash(node) if enforce_no_space_style_for_empty_braces?
         end
 
         private
@@ -103,7 +108,7 @@ module RuboCop
           if is_same_braces && style == :compact
             false
           elsif is_empty_braces
-            cop_config['EnforcedStyleForEmptyBraces'] != 'no_space'
+            !enforce_no_space_style_for_empty_braces?
           else
             style != :no_space
           end
@@ -175,6 +180,28 @@ module RuboCop
 
           range_between(begin_pos, range.end_pos - 1)
         end
+
+        def check_whitespace_only_hash(node)
+          range = range_inside_hash(node)
+          return unless range.source.match?(/\A\s+\z/m)
+
+          add_offense(
+            range,
+            message: format(MSG, problem: 'empty hash literal braces detected')
+          ) do |corrector|
+            corrector.remove(range)
+          end
+        end
+
+        def range_inside_hash(node)
+          return node.source_range if node.location.begin.nil?
+
+          range_between(node.location.begin.end_pos, node.location.end.begin_pos)
+        end
+
+        def enforce_no_space_style_for_empty_braces?
+          cop_config['EnforcedStyleForEmptyBraces'] == 'no_space'
+        end
       end
     end
   end

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

@@ -91,7 +91,7 @@ module RuboCop
             if !left_parens?(token1, token2) && !right_parens?(token1, token2)
               correct_missing_space(token1, token2)
             else
-              correct_extaneus_space_between_consecutive_parens(token1, token2)
+              correct_extraneous_space_between_consecutive_parens(token1, token2)
             end
           end
         end
@@ -112,7 +112,7 @@ module RuboCop
           end
         end
 
-        def correct_extaneus_space_between_consecutive_parens(token1, token2)
+        def correct_extraneous_space_between_consecutive_parens(token1, token2)
           return if range_between(token1.end_pos, token2.begin_pos).source != ' '
 
           range = range_between(token1.end_pos, token2.begin_pos)