rubocop 1.57.0 → 1.58.0

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

@@ -17,10 +17,16 @@ module RuboCop
       # @example
       #   # bad
       #   hash.keys.each { |k| p k }
-      #   hash.values.each { |v| p v }
+      #   hash.each { |k, unused_value| p k }
       #
       #   # good
       #   hash.each_key { |k| p k }
+      #
+      #   # bad
+      #   hash.values.each { |v| p v }
+      #   hash.each { |unused_key, v| p v }
+      #
+      #   # good
       #   hash.each_value { |v| p v }
       #
       # @example AllowedReceivers: ['execute']
@@ -33,22 +39,44 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        UNUSED_BLOCK_ARG_MSG = "#{MSG.chop} and remove the unused `%<unused_code>s` block argument."
 
         # @!method kv_each(node)
         def_node_matcher :kv_each, <<~PATTERN
-          ({block numblock} $(send (send _ ${:keys :values}) :each) ...)
+          ({block numblock} $(call (call _ ${:keys :values}) :each) ...)
+        PATTERN
+
+        # @!method each_arguments(node)
+        def_node_matcher :each_arguments, <<~PATTERN
+          (block (call _ :each)(args $_key $_value) ...)
         PATTERN
 
         # @!method kv_each_with_block_pass(node)
         def_node_matcher :kv_each_with_block_pass, <<~PATTERN
-          (send $(send _ ${:keys :values}) :each (block_pass (sym _)))
+          (call $(call _ ${:keys :values}) :each (block_pass (sym _)))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_block(node)
           kv_each(node) do |target, method|
-            register_kv_offense(target, method)
+            register_kv_offense(target, method) and return
+          end
+
+          return unless (key, value = each_arguments(node))
+
+          if unused_block_arg_exist?(node, value.source)
+            message = message('each_key', node.method_name, value.source)
+            unused_range = key.source_range.end.join(value.source_range.end)
+
+            register_each_args_offense(node, message, 'each_key', unused_range)
+          elsif unused_block_arg_exist?(node, key.source)
+            message = message('each_value', node.method_name, key.source)
+            unused_range = key.source_range.begin.join(value.source_range.begin)
+
+            register_each_args_offense(node, message, 'each_value', unused_range)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         alias on_numblock on_block
 
@@ -64,23 +92,43 @@ module RuboCop
           return unless (parent_receiver = target.receiver.receiver)
           return if allowed_receiver?(parent_receiver)
 
-          add_offense(kv_range(target), message: format_message(method)) do |corrector|
+          current = target.receiver.loc.selector.join(target.source_range.end).source
+
+          add_offense(kv_range(target), message: format_message(method, current)) do |corrector|
             correct_key_value_each(target, corrector)
           end
         end
 
+        def unused_block_arg_exist?(node, block_arg_source)
+          node.body.each_descendant(:lvar).map(&:source).none?(block_arg_source)
+        end
+
+        def message(prefer, method_name, unused_code)
+          format(
+            UNUSED_BLOCK_ARG_MSG, prefer: prefer, current: method_name, unused_code: unused_code
+          )
+        end
+
+        def register_each_args_offense(node, message, prefer, unused_range)
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node.send_node.loc.selector, prefer)
+            corrector.remove(unused_range)
+          end
+        end
+
         def register_kv_with_block_pass_offense(node, target, method)
           return unless (parent_receiver = node.parent.receiver.receiver)
           return if allowed_receiver?(parent_receiver)
 
-          range = target.loc.selector.with(end_pos: node.parent.loc.selector.end_pos)
-          add_offense(range, message: format_message(method)) do |corrector|
+          range = target.loc.selector.join(node.parent.loc.selector.end)
+
+          add_offense(range, message: format_message(method, range.source)) do |corrector|
             corrector.replace(range, "each_#{method[0..-2]}")
           end
         end
 
-        def format_message(method_name)
-          format(MSG, prefer: "each_#{method_name[0..-2]}", current: "#{method_name}.each")
+        def format_message(method_name, current)
+          format(MSG, prefer: "each_#{method_name[0..-2]}", current: current)
         end
 
         def check_argument(variable)
@@ -103,7 +151,7 @@ module RuboCop
           name = "each_#{node.receiver.method_name.to_s.chop}"
           return correct_implicit(node, corrector, name) unless receiver
 
-          new_source = receiver.source + ".#{name}"
+          new_source = receiver.source + "#{node.loc.dot.source}#{name}"
           corrector.replace(node, new_source)
         end
 

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

@@ -153,7 +153,15 @@ module RuboCop
           return unless duplicated_expressions?(node, heads)
 
           condition_variable = assignable_condition_value(node)
-          return if heads.first.assignment? && condition_variable == heads.first.name.to_s
+
+          head = heads.first
+          if head.assignment?
+            # The `send` node is used instead of the `indexasgn` node, so `name` cannot be used.
+            # https://github.com/rubocop/rubocop-ast/blob/v1.29.0/lib/rubocop/ast/node/indexasgn_node.rb
+            assigned_value = head.send_type? ? head.receiver.source : head.name.to_s
+
+            return if condition_variable == assigned_value
+          end
 
           check_expressions(node, heads, :before_condition)
         end

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

@@ -60,17 +60,17 @@ module RuboCop
         # @!method inverse_candidate?(node)
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
-            (send $(send $(...) $_ $...) :!)
-            (send ({block numblock} $(send $(...) $_) $...) :!)
-            (send (begin $(send $(...) $_ $...)) :!)
+            (send $(call $(...) $_ $...) :!)
+            (send ({block numblock} $(call $(...) $_) $...) :!)
+            (send (begin $(call $(...) $_ $...)) :!)
           }
         PATTERN
 
         # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
-          ({block numblock} $(send (...) $_) ... { $(send ... :!)
+          ({block numblock} $(call (...) $_) ... { $(call ... :!)
                                                    $(send (...) {:!= :!~} ...)
-                                                   (begin ... $(send ... :!))
+                                                   (begin ... $(call ... :!))
                                                    (begin ... $(send (...) {:!= :!~} ...))
                                                  })
         PATTERN
@@ -87,6 +87,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         def on_block(node)
           inverse_block?(node) do |_method_call, method, block|

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

@@ -34,21 +34,25 @@ module RuboCop
 
         minimum_target_ruby_version 2.6
 
-        MSG = 'Pass a block to `to_h` instead of calling `%<method>s.to_h`.'
+        MSG = 'Pass a block to `to_h` instead of calling `%<method>s%<dot>sto_h`.'
         RESTRICT_ON_SEND = %i[to_h].freeze
 
         # @!method map_to_h?(node)
         def_node_matcher :map_to_h?, <<~PATTERN
           {
-            $(send ({block numblock} $(send _ {:map :collect}) ...) :to_h)
-            $(send $(send _ {:map :collect} (block_pass sym)) :to_h)
+            $(call ({block numblock} $(call _ {:map :collect}) ...) :to_h)
+            $(call $(call _ {:map :collect} (block_pass sym)) :to_h)
           }
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Layout::SingleLineBlockChain]
+        end
+
         def on_send(node)
           return unless (to_h_node, map_node = map_to_h?(node))
 
-          message = format(MSG, method: map_node.loc.selector.source)
+          message = format(MSG, method: map_node.loc.selector.source, dot: map_node.loc.dot.source)
           add_offense(map_node.loc.selector, message: message) do |corrector|
             # If the `to_h` call already has a block, do not autocorrect.
             next if to_h_node.block_node
@@ -56,6 +60,7 @@ module RuboCop
             autocorrect(corrector, to_h_node, map_node)
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -239,7 +239,7 @@ module RuboCop
         def args_parenthesized?(node)
           return false unless node.arguments.one?
 
-          first_node = node.arguments.first
+          first_node = node.first_argument
           first_node.begin_type? && first_node.parenthesized_call?
         end
       end

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

@@ -170,7 +170,7 @@ module RuboCop
           return true if node.arguments.any? do |arg|
             arg.forward_arg_type? || arg.restarg_type? || arg.kwrestarg_type?
           end
-          return false unless (last_argument = node.arguments.last)
+          return false unless (last_argument = node.last_argument)
 
           last_argument.blockarg_type? && last_argument.name.nil?
         end

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

@@ -7,12 +7,12 @@ module RuboCop
       # defining `respond_to_missing?`.
       #
       # @example
-      #   #bad
+      #   # bad
       #   def method_missing(name, *args)
       #     # ...
       #   end
       #
-      #   #good
+      #   # good
       #   def respond_to_missing?(name, include_private)
       #     # ...
       #   end

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

@@ -67,7 +67,7 @@ module RuboCop
           return unless redundant_argument?(node)
 
           offense_range = argument_range(node)
-          message = format(MSG, arg: node.arguments.first.source)
+          message = format(MSG, arg: node.first_argument.source)
 
           add_offense(offense_range, message: message) do |corrector|
             corrector.remove(offense_range)
@@ -80,7 +80,7 @@ module RuboCop
           redundant_argument = redundant_arg_for_method(node.method_name.to_s)
           return false if redundant_argument.nil?
 
-          node.arguments.first == redundant_argument
+          node.first_argument == redundant_argument
         end
 
         def redundant_arg_for_method(method_name)

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

@@ -25,21 +25,33 @@ module RuboCop
         MSG = 'Remove the redundant double splat and braces, use keyword arguments directly.'
         MERGE_METHODS = %i[merge merge!].freeze
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_hash(node)
-          return if !node.braces? || node.pairs.empty? || node.pairs.any?(&:hash_rocket?)
+          return if node.pairs.empty? || node.pairs.any?(&:hash_rocket?)
           return unless (parent = node.parent)
+          return unless parent.call_type? || parent.kwsplat_type?
+          return unless mergeable?(parent)
           return unless (kwsplat = node.each_ancestor(:kwsplat).first)
-          return if parent.call_type? && !merge_method?(parent)
+          return if !node.braces? || allowed_double_splat_receiver?(kwsplat)
 
           add_offense(kwsplat) do |corrector|
             autocorrect(corrector, node, kwsplat)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
+        def allowed_double_splat_receiver?(kwsplat)
+          first_child = kwsplat.children.first
+          return true if first_child.block_type? || first_child.numblock_type?
+          return false unless first_child.call_type?
+
+          root_receiver = root_receiver(first_child)
+
+          !root_receiver&.hash_type?
+        end
+
         def autocorrect(corrector, node, kwsplat)
           corrector.remove(kwsplat.loc.operator)
           corrector.remove(opening_brace(node))
@@ -51,9 +63,18 @@ module RuboCop
           autocorrect_merge_methods(corrector, merge_methods, kwsplat)
         end
 
+        def root_receiver(node)
+          receiver = node.receiver
+          if receiver&.receiver
+            root_receiver(receiver)
+          else
+            receiver
+          end
+        end
+
         def select_merge_method_nodes(kwsplat)
           extract_send_methods(kwsplat).select do |node|
-            merge_method?(node)
+            mergeable?(node)
           end
         end
 
@@ -84,11 +105,11 @@ module RuboCop
         end
 
         def extract_send_methods(kwsplat)
-          @extract_send_methods ||= kwsplat.each_descendant(:send, :csend)
+          kwsplat.each_descendant(:send, :csend)
         end
 
         def convert_to_new_arguments(node)
-          return unless merge_method?(node)
+          return unless mergeable?(node)
 
           node.arguments.map do |arg|
             if arg.hash_type?
@@ -99,8 +120,12 @@ module RuboCop
           end
         end
 
-        def merge_method?(node)
-          MERGE_METHODS.include?(node.method_name)
+        def mergeable?(node)
+          return true unless node.call_type?
+          return false unless MERGE_METHODS.include?(node.method_name)
+          return true unless (parent = node.parent)
+
+          mergeable?(parent)
         end
       end
     end

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

@@ -5,17 +5,21 @@ module RuboCop
     module Style
       # Checks for RuntimeError as the argument of raise/fail.
       #
-      # It checks for code like this:
-      #
       # @example
-      #   # Bad
+      #   # bad
       #   raise RuntimeError, 'message'
-      #
-      #   # Bad
       #   raise RuntimeError.new('message')
       #
-      #   # Good
+      #   # good
       #   raise 'message'
+      #
+      #   # bad - message is not a string
+      #   raise RuntimeError, Object.new
+      #   raise RuntimeError.new(Object.new)
+      #
+      #   # good
+      #   raise Object.new.to_s
+      #
       class RedundantException < Base
         extend AutoCorrector
 
@@ -30,26 +34,42 @@ module RuboCop
           fix_exploded(node) || fix_compact(node)
         end
 
+        private
+
         def fix_exploded(node)
           exploded?(node) do |command, message|
             add_offense(node, message: MSG_1) do |corrector|
-              if node.parenthesized?
-                corrector.replace(node, "#{command}(#{message.source})")
-              else
-                corrector.replace(node, "#{command} #{message.source}")
-              end
+              corrector.replace(node, replaced_exploded(node, command, message))
             end
           end
         end
 
+        def replaced_exploded(node, command, message)
+          arg = string_message?(message) ? message.source : "#{message.source}.to_s"
+          arg = node.parenthesized? ? "(#{arg})" : " #{arg}"
+          "#{command}#{arg}"
+        end
+
+        def string_message?(message)
+          message.str_type? || message.dstr_type? || message.xstr_type?
+        end
+
         def fix_compact(node)
           compact?(node) do |new_call, message|
             add_offense(node, message: MSG_2) do |corrector|
-              corrector.replace(new_call, message.source)
+              corrector.replace(new_call, replaced_compact(message))
             end
           end
         end
 
+        def replaced_compact(message)
+          if string_message?(message)
+            message.source
+          else
+            "#{message.source}.to_s"
+          end
+        end
+
         # @!method exploded?(node)
         def_node_matcher :exploded?, <<~PATTERN
           (send nil? ${:raise :fail} (const {nil? cbase} :RuntimeError) $_)

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

@@ -60,10 +60,10 @@ module RuboCop
 
         # @!method select_predicate?(node)
         def_node_matcher :select_predicate?, <<~PATTERN
-          (send
+          (call
             {
-              (block $(send _ {:select :filter :find_all}) ...)
-              $(send _ {:select :filter :find_all} block_pass_type?)
+              (block $(call _ {:select :filter :find_all}) ...)
+              $(call _ {:select :filter :find_all} block_pass_type?)
             }
             ${:#{RESTRICT_ON_SEND.join(' :')}})
         PATTERN
@@ -87,6 +87,7 @@ module RuboCop
             register_offense(select_node, node)
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -107,6 +107,8 @@ module RuboCop
 
         def inside_string_literal_or_method_with_argument?(range)
           processed_source.tokens.each_cons(2).any? do |token, next_token|
+            next if token.line == next_token.line
+
             inside_string_literal?(range, token) || method_with_argument?(token, next_token)
           end
         end

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

@@ -17,6 +17,8 @@ module RuboCop
         include Parentheses
         extend AutoCorrector
 
+        ALLOWED_NODE_TYPES = %i[and or send splat kwsplat].freeze
+
         # @!method square_brackets?(node)
         def_node_matcher :square_brackets?, '(send {(send _recv _msg) str array hash} :[] ...)'
 
@@ -111,17 +113,19 @@ module RuboCop
 
         def first_arg_begins_with_hash_literal?(node)
           # Don't flag `method ({key: value})` or `method ({key: value}.method)`
-          method_chain_begins_with_hash_literal?(node.children.first) &&
-            first_argument?(node) &&
-            !parentheses?(node.parent)
+          hash_literal = method_chain_begins_with_hash_literal(node.children.first)
+          if (root_method = node.each_ancestor(:send).to_a.last)
+            parenthesized = root_method.parenthesized_call?
+          end
+          hash_literal && first_argument?(node) && !parentheses?(hash_literal) && !parenthesized
         end
 
-        def method_chain_begins_with_hash_literal?(node)
-          return false if node.nil?
-          return true if node.hash_type?
-          return false unless node.send_type?
+        def method_chain_begins_with_hash_literal(node)
+          return if node.nil?
+          return node if node.hash_type?
+          return unless node.send_type?
 
-          method_chain_begins_with_hash_literal?(node.children.first)
+          method_chain_begins_with_hash_literal(node.children.first)
         end
 
         def check(begin_node)
@@ -134,23 +138,29 @@ module RuboCop
           check_send(begin_node, node) if node.call_type?
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def find_offense_message(begin_node, node)
           return 'a keyword' if keyword_with_redundant_parentheses?(node)
           return 'a literal' if disallowed_literal?(begin_node, node)
           return 'a variable' if node.variable?
           return 'a constant' if node.const_type?
+          return 'an expression' if node.lambda_or_proc?
           return 'an interpolated expression' if interpolation?(begin_node)
 
-          return if begin_node.chained? || !begin_node.parent.nil?
+          return if begin_node.chained?
 
           if node.and_type? || node.or_type?
+            return if ALLOWED_NODE_TYPES.include?(begin_node.parent&.type)
+            return if begin_node.parent&.if_type? && begin_node.parent&.ternary?
+
             'a logical expression'
           elsif node.respond_to?(:comparison_method?) && node.comparison_method?
+            return unless begin_node.parent.nil?
+
             'a comparison expression'
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         # @!method interpolation?(node)
         def_node_matcher :interpolation?, '[^begin ^^dstr]'
@@ -231,7 +241,13 @@ module RuboCop
         end
 
         def first_argument?(node)
-          first_send_argument?(node) || first_super_argument?(node) || first_yield_argument?(node)
+          if first_send_argument?(node) ||
+             first_super_argument?(node) ||
+             first_yield_argument?(node)
+            return true
+          end
+
+          node.each_ancestor.any? { |ancestor| first_argument?(ancestor) }
         end
 
         # @!method first_send_argument?(node)

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

@@ -58,7 +58,7 @@ module RuboCop
 
         MSG = 'Redundant `return` detected.'
         MULTI_RETURN_MSG = 'To return multiple values, use an array.'
-        RESTRICT_ON_SEND = %i[define_method define_singleton_method].freeze
+        RESTRICT_ON_SEND = %i[define_method define_singleton_method lambda].freeze
 
         def on_send(node)
           return unless (parent = node.parent) && parent.block_type?

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

@@ -180,7 +180,7 @@ module RuboCop
         end
 
         def arg_node(node)
-          node.arguments.first
+          node.first_argument
         end
 
         def arg_value(node)

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

@@ -133,7 +133,7 @@ module RuboCop
         end
 
         def percent_array_literal?(node)
-          (percent_w_literal?(node) || percent_w_upper_literal?(node))
+          percent_w_literal?(node) || percent_w_upper_literal?(node)
         end
 
         def heredoc_with_disabled_interpolation?(node)

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

@@ -146,7 +146,7 @@ module RuboCop
           return node.child_nodes.first if node.match_with_lvasgn_type?
 
           if node.receiver.lvar_type? &&
-             (block.numblock_type? || node.receiver.source == block.arguments.first.source)
+             (block.numblock_type? || node.receiver.source == block.first_argument.source)
             node.first_argument
           elsif node.first_argument.lvar_type?
             node.receiver

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

@@ -16,7 +16,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use self-assignment shorthand `%<method>s=`.'
-        OPS = %i[+ - * ** / | &].freeze
+        OPS = %i[+ - * ** / % ^ << >> | &].freeze
 
         def self.autocorrect_incompatible_with
           [Layout::SpaceAroundOperators]

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

@@ -80,6 +80,7 @@ module RuboCop
           processed_source.tokens.group_by(&:line)
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def semicolon_position(tokens)
           if tokens.last.semicolon?
             -1
@@ -90,10 +91,13 @@ module RuboCop
           elsif exist_semicolon_after_left_curly_brace?(tokens) ||
                 exist_semicolon_after_left_string_interpolation_brace?(tokens)
             2
+          elsif exist_semicolon_after_left_lambda_curly_brace?(tokens)
+            3
           elsif exist_semicolon_before_right_string_interpolation_brace?(tokens)
             -4
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def exist_semicolon_before_right_curly_brace?(tokens)
           tokens[-2]&.right_curly_brace? && tokens[-3]&.semicolon?
@@ -103,6 +107,10 @@ module RuboCop
           tokens[1]&.left_curly_brace? && tokens[2]&.semicolon?
         end
 
+        def exist_semicolon_after_left_lambda_curly_brace?(tokens)
+          tokens[2]&.type == :tLAMBEG && tokens[3]&.semicolon?
+        end
+
         def exist_semicolon_before_right_string_interpolation_brace?(tokens)
           tokens[-3]&.type == :tSTRING_DEND && tokens[-4]&.semicolon?
         end

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

@@ -33,6 +33,7 @@ module RuboCop
 
         MSG = 'Use `%<receiver>s[%<argument>s]` instead of `%<original>s`.'
         RESTRICT_ON_SEND = %i[dig].freeze
+        IGNORED_ARGUMENT_TYPES = %i[block_pass forwarded_restarg forwarded_args hash].freeze
 
         # @!method single_argument_dig?(node)
         def_node_matcher :single_argument_dig?, <<~PATTERN
@@ -44,7 +45,7 @@ module RuboCop
 
           expression = single_argument_dig?(node)
           return unless expression
-          return if expression.forwarded_args_type?
+          return if IGNORED_ARGUMENT_TYPES.include?(expression.type)
 
           receiver = node.receiver.source
           argument = expression.source

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

@@ -30,6 +30,7 @@ module RuboCop
 
         MSG = 'Prefer multiline `do`...`end` block.'
 
+        # rubocop:disable Metrics/AbcSize
         def on_block(node)
           return if !node.single_line? || node.braces?
 
@@ -42,10 +43,11 @@ module RuboCop
               corrector.remove(node.loc.end)
               corrector.insert_after(node_body.loc.heredoc_end, "\nend")
             else
-              corrector.insert_after(node_body, "\n")
+              corrector.insert_before(node.loc.end, "\n")
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize
         alias on_numblock on_block
 
         private