rubocop 1.91.0 → 1.92.2

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

@@ -72,6 +72,22 @@ module RuboCop
 
         MSG = 'Line is too long. [%<length>d/%<max>d]'
 
+        # A trailing backslash, or a trailing unicode, hex, octal, meta or control escape whose
+        # payload may be incomplete. An even run of backslashes is complete on its own.
+        # Meta and control prefixes chain (`\M-\C-x`, `\c\M-x`), so a whole chain is one escape,
+        # and a braced unicode escape may hold several space-separated codepoints.
+        ESCAPE_SEQUENCE_TAIL = /
+          (?<!\\)(?:\\\\)*
+          (
+            \\(?:(?:[MC]-|c)\\)*
+            (?:u\{[\da-f\x20]*|u[\da-f]{0,4}|x[\da-f]{0,2}|[0-7]{0,3}|[MC]-?|c)?
+          )\z
+        /xi.freeze
+
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses, Style::MethodDefParentheses]
+        end
+
         def on_block(node)
           check_for_breakable_block(node)
         end
@@ -106,8 +122,10 @@ module RuboCop
         def on_new_investigation
           @breakable_range_by_line_index = {}
           @breakable_string_delimiters = {}
+          @breakable_strings = {}
           @endless_methods_by_line = {}
           @heredocs = nil
+          @heredoc_openers = nil
 
           return unless processed_source.raw_source.include?(';')
 
@@ -191,35 +209,69 @@ module RuboCop
         def check_for_breakable_node(node)
           breakable_node = extract_breakable_node(node, max)
           return if breakable_node.nil?
+          return if compact_nested_array_break?(node, breakable_node)
 
           line_index = breakable_node.first_line - 1
           range = breakable_node.source_range
 
           existing = breakable_range_by_line_index[line_index]
-          return if existing
+          return if existing || after_heredoc_opener?(range)
 
           breakable_range_by_line_index[line_index] = range
         end
 
+        def after_heredoc_opener?(range)
+          heredoc_openers.any? do |opener|
+            opener.line == range.line && opener.begin_pos < range.begin_pos
+          end
+        end
+
+        def heredoc_openers
+          ast = processed_source.ast
+          return [] if ast.nil?
+
+          @heredoc_openers ||= ast.each_node(:any_str).select(&:heredoc?).map(&:source_range)
+        end
+
+        def compact_nested_array_break?(node, breakable_node)
+          return false if !node.array_type? || !node.square_brackets?
+          return false unless breakable_node.equal?(node.children.first)
+          return false unless breakable_node.source.start_with?('[')
+
+          compact_array_brackets_enforced?
+        end
+
+        def compact_array_brackets_enforced?
+          return false unless config.cop_enabled?('Layout/SpaceInsideArrayLiteralBrackets')
+
+          config.for_cop('Layout/SpaceInsideArrayLiteralBrackets')['EnforcedStyle'] == 'compact'
+        end
+
         def check_for_breakable_semicolons(processed_source)
           tokens = processed_source.tokens.select { |t| t.type == :tSEMI }
           tokens.reverse_each do |token|
             range = breakable_range_after_semicolon(token)
-            breakable_range_by_line_index[range.line - 1] = range if range
+            next if range.nil? || after_heredoc_opener?(range)
+
+            breakable_range_by_line_index[range.line - 1] = range
           end
         end
 
         def check_for_breakable_block(block_node)
           return unless block_node.single_line?
-          return if receiver_contains_heredoc?(block_node)
 
           line_index = block_node.loc.line - 1
+          return if breakable_string_delimiters[line_index]
+
           range = breakable_block_range(block_node)
           pos = range.begin_pos + 1
+          range = range_between(pos, pos + 1)
+          return if after_heredoc_opener?(range)
 
-          breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
+          breakable_range_by_line_index[line_index] = range
         end
 
+        # rubocop:disable-next Metrics/AbcSize
         def check_for_breakable_str(node)
           line_index = node.loc.line - 1
           return if breakable_range_by_line_index[line_index]
@@ -230,6 +282,7 @@ module RuboCop
 
           breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
           breakable_string_delimiters[line_index] = delimiter
+          breakable_strings[line_index] = node
         end
 
         def check_for_breakable_dstr(node) # rubocop:disable Metrics/AbcSize
@@ -253,7 +306,8 @@ module RuboCop
             !node.heredoc? &&
             # TODO: strings inside hashes, kwargs and arrays are currently ignored,
             # but could be considered in the future
-            !node.parent&.type?(:pair, :kwoptarg, :array)
+            !node.parent&.type?(:pair, :kwoptarg, :array) &&
+            !after_heredoc_opener?(node.source_range)
         end
 
         def breakable_block_range(block_node)
@@ -282,7 +336,33 @@ module RuboCop
           return if source_range.last_column < max
           return unless (pos = breakable_string_range(node))
 
-          pos.end_pos unless pos.end_pos == source_range.begin_pos
+          content_begin_pos = node.loc?(:begin) ? node.loc.begin.end_pos : source_range.begin_pos
+          if blank_left_part?(node, content_begin_pos, pos)
+            pos = breakable_string_range_at_limit(source_range)
+          end
+          pos.end_pos if pos && leaves_two_parts?(node, content_begin_pos, pos)
+        end
+
+        def leaves_two_parts?(node, content_begin_pos, pos)
+          pos.end_pos > content_begin_pos && !blank_rest?(node, pos.end_pos)
+        end
+
+        def blank_left_part?(node, content_begin_pos, pos)
+          return false unless pos.end_pos > content_begin_pos
+          return false unless starts_after_quote?(node)
+
+          blank_between?(content_begin_pos, pos.end_pos)
+        end
+
+        def starts_after_quote?(node)
+          return true if node.loc?(:begin)
+
+          quote = node.parent&.loc&.begin if node.parent&.dstr_type?
+          quote ? quote.end_pos == node.source_range.begin_pos : false
+        end
+
+        def blank_between?(begin_pos, end_pos)
+          range_between(begin_pos, end_pos).source.strip.empty?
         end
 
         # Locate where to break a string that is too long, ensuring that escape characters
@@ -294,24 +374,57 @@ module RuboCop
           relevant_substr = largest_possible_string(node)
 
           if (space_pos = breakable_space_position(node, relevant_substr))
-            source_range.resize(space_pos + 1)
-          elsif (escape_pos = relevant_substr.rindex(/\\(u[\da-f]{0,4}|x[\da-f]{0,2})?\z/))
+            # A space can separate codepoints inside a braced unicode escape.
+            escape_pos = escape_sequence_start(relevant_substr[0..space_pos])
+            source_range.resize(escape_pos || (space_pos + 1))
+          elsif (escape_pos = escape_sequence_start(relevant_substr))
             source_range.resize(escape_pos)
           else
-            adjustment = max - source_range.last_column - 3
-            return if adjustment.abs > source_range.size
-
-            source_range.adjust(end_pos: adjustment)
+            breakable_string_range_at_limit(source_range)
           end
         end
 
         def breakable_space_position(node, substr)
           limit = string_content_length(node) - 1
-          space_pos = substr.rindex(/\s/)
-          space_pos = substr[0, limit].rindex(/\s/) if space_pos && space_pos + 1 > limit
+          space_pos = space_before_word(node, substr.length - 1)
+          space_pos = space_before_word(node, limit - 1) if space_pos && space_pos + 1 > limit
           space_pos
         end
 
+        def space_before_word(node, max_pos)
+          return if max_pos.negative?
+
+          node.source.rindex(/\s(?=\S)/, max_pos)
+        end
+
+        def escape_sequence_start(text)
+          text.match(ESCAPE_SEQUENCE_TAIL)&.begin(1)
+        end
+
+        def breakable_string_range_at_limit(source_range)
+          adjustment = max - source_range.last_column - 3
+          return if adjustment.abs > source_range.size
+
+          cut = source_range.adjust(end_pos: adjustment)
+          cut = cut.resize(size_before_whitespace_run(source_range.source, cut.size))
+          escape_pos = escape_sequence_start(cut.source)
+
+          escape_pos ? source_range.resize(escape_pos) : cut
+        end
+
+        def size_before_whitespace_run(text, size)
+          return size if size.zero?
+          return size unless text[size]&.match?(/\s/)
+
+          text.rindex(/\S/, size - 1) || size
+        end
+
+        def blank_rest?(node, break_pos)
+          offset = break_pos - node.source_range.begin_pos
+
+          node.source[offset...string_content_length(node)].strip.empty?
+        end
+
         def string_content_length(node)
           content_end = node.loc?(:end) ? node.loc.end.begin_pos : node.source_range.end_pos
 
@@ -320,7 +433,18 @@ module RuboCop
 
         def breakable_dstr_begin_position(node)
           source_range = node.source_range
-          source_range.begin_pos if source_range.column < max && source_range.last_column >= max
+          return unless source_range.column < max && source_range.last_column >= max
+          return if opens_string?(node)
+
+          source_range.begin_pos
+        end
+
+        def opens_string?(begin_node)
+          quote = begin_node.parent.loc.begin
+
+          return false unless quote
+
+          blank_between?(quote.end_pos, begin_node.source_range.begin_pos)
         end
 
         def breakable_range_by_line_index
@@ -335,6 +459,10 @@ module RuboCop
           @breakable_string_delimiters ||= {}
         end
 
+        def breakable_strings
+          @breakable_strings ||= {}
+        end
+
         def heredocs
           @heredocs ||= extract_heredocs(processed_source.ast)
         end
@@ -391,8 +519,36 @@ module RuboCop
                           "\n"
                         end
 
-            corrector.insert_before(breakable_range, insertion) unless breakable_range.nil?
+            break_ranges(line_index).each do |range|
+              corrector.insert_before(range, insertion)
+            end
+          end
+        end
+
+        def break_ranges(line_index)
+          return [] if breakable_range.nil?
+          return [breakable_range] unless (node = breakable_strings[line_index])&.loc?(:end)
+
+          string_break_ranges(node, breakable_string_delimiters[line_index])
+        end
+
+        def string_break_ranges(node, delimiter)
+          ranges = [breakable_range]
+          pos = breakable_range.begin_pos
+
+          while (pos = next_string_break_position(node, pos, delimiter))
+            ranges << range_between(pos, pos + 1)
           end
+
+          ranges
+        end
+
+        def next_string_break_position(node, pos, delimiter)
+          rest = parse("#{delimiter}#{node.source_range.with(begin_pos: pos).source}").ast
+          return unless rest&.str_type?
+          return unless (rest_pos = breakable_string_position(rest))
+
+          pos + rest_pos - delimiter.length
         end
 
         def excess_range(uri_range, line, line_index)
@@ -511,16 +667,10 @@ module RuboCop
           # `Max` - end delimiter (quote) - continuation characters (space and slash)
           max_length = max - 3
           # Offset by the string's starting column so the broken line actually fits
-          # within `Max`. When on the same line as its parent, use the column difference;
-          # otherwise the string is indented on its own line, so subtract that indentation.
-          # (Without this, an indented string under a multi-line parent never shortens
-          # below `Max` and the autocorrect loops, inserting empty `"" \` fragments.)
-          max_length -= if same_line?(node, node.parent)
-                          column_offset_between(node.loc, node.parent.loc)
-                        else
-                          node.loc.column
-                        end
-          node.source[0...(max_length)]
+          # within `Max`, whatever precedes the string on its line.
+          max_length -= node.loc.column
+
+          node.source[0, [max_length, 0].max]
         end
       end
     end

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

@@ -106,6 +106,18 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'The closing array brace must be on the ' \
                                    'same line as the last array element.'
 
+        # Moving the closing bracket after a hash literal or method call element while
+        # `Layout/MultilineHashBraceLayout` or `Layout/MultilineMethodCallBraceLayout` moves
+        # that element's closing brace in the same pass places the bracket after whatever
+        # follows the moved brace, such as a comment.
+        # Moving it while `Style/ConcatArrayLiterals` removes the brackets in the same pass
+        # leaves the bracket behind.
+        def self.autocorrect_incompatible_with
+          [
+            Layout::MultilineHashBraceLayout, Layout::MultilineMethodCallBraceLayout, Style::ConcatArrayLiterals
+          ]
+        end
+
         def on_array(node)
           check_brace_layout(node)
         end

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

@@ -56,6 +56,13 @@ module RuboCop
         ARG_MSG = 'Block argument expression is not on the same line as the block start.'
         PIPE_SIZE = '|'.length
 
+        # `Style/Lambda` moves the block arguments of `lambda` into `->(...)`, and
+        # `Style/ItBlockParameter` and `Style/HashEachMethods` remove some or all of them,
+        # in the same pass, while this cop moves them next to the block start.
+        def self.autocorrect_incompatible_with
+          [Style::HashEachMethods, Style::ItBlockParameter, Style::Lambda]
+        end
+
         def on_block(node)
           return if node.single_line?
 
@@ -155,7 +162,7 @@ module RuboCop
         end
 
         def include_trailing_comma?(args)
-          arg_count = args.each_descendant(:arg).to_a.size
+          arg_count = args.each_descendant.count(&:argument_type?)
           arg_count == 1 && args.source.include?(',')
         end
       end

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

@@ -106,6 +106,15 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing hash brace must be on the same ' \
                                    'line as the last hash element.'
 
+        # Moving the closing brace after a method call value while
+        # `Layout/MultilineMethodCallBraceLayout` moves that call's closing parenthesis
+        # before a comment in the same pass places the brace after the comment.
+        # Moving it while `Style/HashAsLastArrayItem` or `Style/RedundantDoubleSplatHashBraces`
+        # removes the braces in the same pass leaves the brace behind.
+        def self.autocorrect_incompatible_with
+          [Layout::MultilineMethodCallBraceLayout, Style::HashAsLastArrayItem, Style::RedundantDoubleSplatHashBraces]
+        end
+
         def on_hash(node)
           check_brace_layout(node)
         end

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

@@ -106,6 +106,12 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing method call brace must be on ' \
                                    'the same line as the last argument.'
 
+        # Moving the closing parenthesis and removing it under `omit_parentheses` in the same pass
+        # leaves the moved parenthesis behind.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           check_brace_layout(node)
         end

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

@@ -73,14 +73,28 @@ module RuboCop
         end
 
         def find_pair_ancestor(node)
+          child = node
           node.each_ancestor do |ancestor|
             return ancestor if ancestor.pair_type?
             break if grouped_expression?(ancestor) || inside_arg_list_parentheses?(node, ancestor)
+            break if inside_body?(ancestor, child)
+
+            child = ancestor
           end
 
           nil
         end
 
+        # A block, `begin`, `if` or loop body is a separate set of statements, so
+        # a method chain in it is not the value of a hash pair the body is nested in.
+        # The send node of a block is still part of the value.
+        def inside_body?(ancestor, child)
+          return !child.equal?(ancestor.send_node) if ancestor.any_block_type?
+          return !ancestor.ternary? if ancestor.if_type?
+
+          ancestor.type?(:kwbegin, :while, :until, :for)
+        end
+
         def unwrap_block_node(node)
           node&.any_block_type? ? node.send_node : node
         end
@@ -88,7 +102,7 @@ module RuboCop
         def autocorrect(corrector, node)
           if @send_node.block_node
             correct_selector_only(corrector, node)
-            correct_block(corrector, @send_node.block_node)
+            correct_block(corrector, @send_node.block_node, node.first_line)
           else
             AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
           end
@@ -100,10 +114,21 @@ module RuboCop
           AlignmentCorrector.correct(corrector, processed_source, selector_range, @column_delta)
         end
 
-        def correct_block(corrector, block_node)
-          AlignmentCorrector.correct(corrector, processed_source, block_node.body, @column_delta)
-          end_range = range_by_whole_lines(block_node.loc.end, include_final_newline: false)
-          AlignmentCorrector.correct(corrector, processed_source, end_range, @column_delta)
+        def correct_block(corrector, block_node, selector_line)
+          lines_to_shift = block_lines(block_node) - [selector_line]
+
+          lines_to_shift.each do |line|
+            line_range = processed_source.buffer.line_range(line)
+
+            AlignmentCorrector.correct(corrector, processed_source, line_range, @column_delta)
+          end
+        end
+
+        def block_lines(block_node)
+          body = block_node.body
+          lines = body ? (body.first_line..body.last_line).to_a : []
+
+          (lines << block_node.loc.end.line).uniq
         end
 
         def relevant_node?(send_node)

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

@@ -118,6 +118,10 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing method definition brace must be ' \
                                    'on the same line as the last parameter.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MultilineMethodSignature]
+        end
+
         def on_def(node)
           check_brace_layout(node.arguments)
         end

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

@@ -54,6 +54,11 @@ module RuboCop
 
         MSG = 'Redundant line break detected.'
 
+        def on_new_investigation
+          super
+          @offense_line_ranges = []
+        end
+
         def on_lvasgn(node)
           super unless end_with_percent_blank_string?(processed_source)
         end
@@ -77,12 +82,15 @@ module RuboCop
         end
 
         def check_assignment(node, _rhs)
-          return unless offense?(node)
+          return unless offense?(node) && !part_of_ignored_node?(node)
 
           register_offense(node)
         end
 
         def register_offense(node)
+          line_range = joined_line_range(node)
+          return if too_long_as_single_line?(line_range)
+
           # The exact single-line correction is verified to parse equivalently
           # before the offense is registered, so a join that would change how
           # the code parses is never reported or offered.
@@ -92,6 +100,19 @@ module RuboCop
             corrector.replace(node, to_single_line(node.source).strip)
           end
           ignore_node(node)
+          @offense_line_ranges.reject! { |range| line_range.cover?(range) }
+          @offense_line_ranges << line_range
+        end
+
+        # Offenses registered in the same pass that share a line with `node`
+        # get joined onto that line too, so the combined line has to fit.
+        def joined_line_range(node)
+          sharing_ranges = @offense_line_ranges.select do |range|
+            range.begin <= node.last_line && node.first_line <= range.end
+          end
+          lines = [node.first_line, node.last_line, *sharing_ranges.flat_map(&:minmax)]
+
+          lines.min..lines.max
         end
 
         def apply_reparse_correction(corrector, node)

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

@@ -22,6 +22,7 @@ module RuboCop
       #     puts 'error'
       #   end
       class RescueEnsureAlignment < Base
+        include Alignment
         include RangeHelp
         include EndKeywordAlignment
         extend AutoCorrector
@@ -74,9 +75,10 @@ module RuboCop
           # Some inline node is sitting before current node.
           return nil unless whitespace.source.strip.empty?
 
-          new_column = alignment_location.column
+          indentation = alignment_indentation(alignment_location)
+          return nil if indentation.nil?
 
-          corrector.replace(whitespace, ' ' * new_column)
+          corrector.replace(whitespace, indentation)
         end
 
         def format_message(alignment_node, alignment_loc, kw_loc)
@@ -91,6 +93,17 @@ module RuboCop
           )
         end
 
+        # A run of spaces sized to the target column would be turned back into tabs by
+        # `Layout/IndentationStyle`, generally landing on a different column, so under
+        # tabs the target line's own indentation is reused. There is nothing to reuse
+        # when the target does not start its line.
+        def alignment_indentation(location)
+          return ' ' * location.column unless using_tabs?
+          return unless begins_its_line?(location)
+
+          location.source_line[/\A\s*/]
+        end
+
         # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
         def alignment_source(node, starting_loc)
           ending_loc =
@@ -102,7 +115,7 @@ module RuboCop
               node.loc.name
             when :sclass
               node.identifier.source_range
-            when :masgn
+            when :masgn, :op_asgn, :or_asgn, :and_asgn
               node.lhs.source_range
             else
               # It is a wrapper with receiver of object attribute or access modifier.

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

@@ -25,13 +25,17 @@ module RuboCop
 
         MSG = 'Put method call on a separate line if chained to a single line block.'
 
+        # These cops rewrite a method chained to the block in the same pass,
+        # which must not start a line of its own.
         def self.autocorrect_incompatible_with
-          [Style::MapToHash]
+          [Style::FloatDivision, Style::MapToHash, Style::MapToSet, Style::NilComparison, Style::RedundantSort]
         end
 
         def on_send(node)
           range = offending_range(node)
-          add_offense(range) { |corrector| corrector.insert_before(range, "\n") } if range
+          return if !range || heredoc_opened_before?(node.receiver, range)
+
+          add_offense(range) { |corrector| corrector.insert_before(range, "\n") }
         end
         alias on_csend on_send
 
@@ -63,6 +67,10 @@ module RuboCop
           # l.(1) has no selector, so we use the opening parenthesis instead
           node.loc.selector || node.loc.begin
         end
+
+        def heredoc_opened_before?(receiver, range)
+          receiver.each_node(:any_str).any? { |str| str.heredoc? && str.first_line == range.line }
+        end
       end
     end
   end

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

@@ -20,6 +20,7 @@ module RuboCop
 
         def on_send(node)
           return unless node.prefix_bang? && whitespace_after_operator?(node)
+          return if unary_tilde?(node.receiver)
 
           add_offense(node) do |corrector|
             corrector.remove(
@@ -33,6 +34,10 @@ module RuboCop
         def whitespace_after_operator?(node)
           node.receiver.source_range.begin_pos - node.source_range.begin_pos > 1
         end
+
+        def unary_tilde?(receiver)
+          receiver.send_type? && receiver.unary_operation? && receiver.method?(:~)
+        end
       end
     end
   end

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

@@ -6,7 +6,8 @@ module RuboCop
       # Checks the spacing inside and after block parameters pipes. Line breaks
       # inside parameter pipes are checked by `Layout/MultilineBlockLayout` and
       # not by this cop. Spaces inside a lambda's parameter parentheses are left
-      # to `Layout/SpaceInsideParens` when that cop enforces a conflicting style.
+      # to `Layout/SpaceInsideParens` when that cop is enabled, so the examples
+      # below apply to a lambda only when it is not.
       #
       # @example EnforcedStyleInsidePipes: no_space (default)
       #   # bad
@@ -35,7 +36,7 @@ module RuboCop
 
           return unless node.arguments? && pipes?(arguments)
 
-          check_inside_pipes(arguments) unless conflicting_space_inside_parens_style?(arguments)
+          check_inside_pipes(arguments) unless checked_by_space_inside_parens?(arguments)
           check_after_closing_pipe(arguments) if node.body
           check_each_arg(arguments)
         end
@@ -54,14 +55,8 @@ module RuboCop
           'EnforcedStyleInsidePipes'
         end
 
-        def conflicting_space_inside_parens_style?(arguments)
-          return false unless arguments.loc.begin.source == '('
-
-          case config.for_enabled_cop('Layout/SpaceInsideParens')['EnforcedStyle']
-          when 'no_space' then style == :space
-          when 'space', 'compact' then style == :no_space
-          else false
-          end
+        def checked_by_space_inside_parens?(arguments)
+          arguments.loc.begin.source == '(' && config.cop_enabled?('Layout/SpaceInsideParens')
         end
 
         def check_inside_pipes(arguments)
@@ -153,7 +148,7 @@ module RuboCop
             if node
               corrector.insert_before(node, ' ')
             else
-              corrector.insert_after(target, ' ')
+              corrector.insert_after(range_between(space_begin_pos, space_begin_pos), ' ')
             end
           end
         end

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

@@ -209,6 +209,7 @@ module RuboCop
           end
 
           return unless space_after_missing?(range)
+          return if block_brace_with_no_space_style?(node, range)
 
           add_offense(range, message: format(MSG_AFTER, range: range.source)) do |corrector|
             corrector.insert_after(range, ' ')
@@ -233,6 +234,15 @@ module RuboCop
           !/[\s;,#\\)}\].]/.match?(char)
         end
 
+        def block_brace_with_no_space_style?(node, range)
+          return false unless (parent = node.parent)
+          return false unless parent.any_block_type? && parent.loc.begin&.begin_pos == range.end_pos
+
+          space_before_block_braces_config = config.for_cop('Layout/SpaceBeforeBlockBraces')
+          space_before_block_braces_config.fetch('Enabled', true) &&
+            space_before_block_braces_config['EnforcedStyle'] == 'no_space'
+        end
+
         def accepted_opening_delimiter?(range, char)
           return true unless char