rubocop 1.18.0 → 1.56.0

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

@@ -6,16 +6,6 @@ module RuboCop
       # Checks that brackets used for array literals have or don't have
       # surrounding space depending on configuration.
       #
-      # @example EnforcedStyle: space
-      #   # The `space` style enforces that array literals have
-      #   # surrounding space.
-      #
-      #   # bad
-      #   array = [a, b, c, d]
-      #
-      #   # good
-      #   array = [ a, b, c, d ]
-      #
       # @example EnforcedStyle: no_space (default)
       #   # The `no_space` style enforces that array literals have
       #   # no surrounding space.
@@ -26,6 +16,16 @@ module RuboCop
       #   # good
       #   array = [a, b, c, d]
       #
+      # @example EnforcedStyle: space
+      #   # The `space` style enforces that array literals have
+      #   # surrounding space.
+      #
+      #   # bad
+      #   array = [a, b, c, d]
+      #
+      #   # good
+      #   array = [ a, b, c, d ]
+      #
       # @example EnforcedStyle: compact
       #   # The `compact` style normally requires a space inside
       #   # array brackets, with the exception that successive left
@@ -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

@@ -86,9 +86,9 @@ module RuboCop
           return if node.keywords?
 
           # Do not register an offense for multi-line empty braces. That means
-          # preventing auto-correction to single-line empty braces. It will
-          # conflict with auto-correction by `Layout/SpaceInsideBlockBraces` cop
-          # if auto-corrected to a single-line empty braces.
+          # preventing autocorrection to single-line empty braces. It will
+          # conflict with autocorrection by `Layout/SpaceInsideBlockBraces` cop
+          # if autocorrected to a single-line empty braces.
           # See: https://github.com/rubocop/rubocop/issues/7363
           return if node.body.nil? && node.multiline?
 
@@ -98,6 +98,8 @@ module RuboCop
           check_inside(node, left_brace, right_brace)
         end
 
+        alias on_numblock on_block
+
         private
 
         def check_inside(node, left_brace, right_brace)
@@ -126,10 +128,10 @@ module RuboCop
         end
 
         def braces_with_contents_inside(node, inner)
-          args_delimiter = node.arguments.loc.begin # Can be ( | or nil.
+          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)
@@ -140,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
 
@@ -155,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)
@@ -185,7 +192,7 @@ module RuboCop
                       'Space between { and | detected.')
             end
           else
-            brace_with_space = range_with_surrounding_space(range: left_brace, side: :right)
+            brace_with_space = range_with_surrounding_space(left_brace, side: :right)
             space(brace_with_space.begin_pos + 1, brace_with_space.end_pos,
                   'Space inside { detected.')
           end
@@ -195,10 +202,21 @@ module RuboCop
           args_delimiter&.is?('|')
         end
 
-        def space_inside_right_brace(right_brace)
-          brace_with_space = range_with_surrounding_space(range: right_brace, side: :left)
-          space(brace_with_space.begin_pos, brace_with_space.end_pos - 1,
-                'Space inside } detected.')
+        def space_inside_right_brace(inner, right_brace, column)
+          brace_with_space = range_with_surrounding_space(right_brace, side: :left)
+          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)
@@ -218,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

@@ -33,6 +33,27 @@ module RuboCop
       #   g = ( a + 3 )
       #   y()
       #
+      # @example EnforcedStyle: compact
+      #   # The `compact` style enforces that parentheses have a space at the
+      #   # beginning with the exception that successive parentheses are allowed.
+      #   # Note: Empty parentheses should not have spaces.
+      #
+      #   # bad
+      #   f(3)
+      #   g = (a + 3)
+      #   y( )
+      #   g( f( x ) )
+      #   g( f( x( 3 ) ), 5 )
+      #   g( ( ( 3 + 5 ) * f) ** x, 5 )
+      #
+      #   # good
+      #   f( 3 )
+      #   g = ( a + 3 )
+      #   y()
+      #   g( f( x ))
+      #   g( f( x( 3 )), 5 )
+      #   g((( 3 + 5 ) * f ) ** x, 5 )
+      #
       class SpaceInsideParens < Base
         include SurroundingSpace
         include RangeHelp
@@ -43,37 +64,39 @@ module RuboCop
         MSG_SPACE = 'No space inside parentheses detected.'
 
         def on_new_investigation
-          @processed_source = processed_source
+          tokens = processed_source.sorted_tokens
 
-          if style == :space
-            process_with_space_style(processed_source)
+          case style
+          when :space
+            process_with_space_style(tokens)
+          when :compact
+            process_with_compact_style(tokens)
           else
-            each_extraneous_space(processed_source.tokens) do |range|
-              add_offense(range) do |corrector|
-                corrector.remove(range)
-              end
-            end
+            correct_extraneous_space(tokens)
           end
         end
 
         private
 
-        def process_with_space_style(processed_source)
-          processed_source.tokens.each_cons(2) do |token1, token2|
-            each_extraneous_space_in_empty_parens(token1, token2) do |range|
-              add_offense(range) do |corrector|
-                corrector.remove(range)
-              end
-            end
-            each_missing_space(token1, token2) do |range|
-              add_offense(range, message: MSG_SPACE) do |corrector|
-                corrector.insert_before(range, ' ')
-              end
+        def process_with_space_style(tokens)
+          tokens.each_cons(2) do |token1, token2|
+            correct_extraneous_space_in_empty_parens(token1, token2)
+            correct_missing_space(token1, token2)
+          end
+        end
+
+        def process_with_compact_style(tokens)
+          tokens.each_cons(2) do |token1, token2|
+            correct_extraneous_space_in_empty_parens(token1, token2)
+            if !left_parens?(token1, token2) && !right_parens?(token1, token2)
+              correct_missing_space(token1, token2)
+            else
+              correct_extraneous_space_between_consecutive_parens(token1, token2)
             end
           end
         end
 
-        def each_extraneous_space(tokens)
+        def correct_extraneous_space(tokens)
           tokens.each_cons(2) do |token1, token2|
             next unless parens?(token1, token2)
 
@@ -82,36 +105,59 @@ module RuboCop
             next if token2.comment?
             next unless same_line?(token1, token2) && token1.space_after?
 
-            yield range_between(token1.end_pos, token2.begin_pos)
+            range = range_between(token1.end_pos, token2.begin_pos)
+            add_offense(range) do |corrector|
+              corrector.remove(range)
+            end
+          end
+        end
+
+        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)
+          add_offense(range) do |corrector|
+            corrector.remove(range)
           end
         end
 
-        def each_extraneous_space_in_empty_parens(token1, token2)
+        def correct_extraneous_space_in_empty_parens(token1, token2)
           return unless token1.left_parens? && token2.right_parens?
 
           return if range_between(token1.begin_pos, token2.end_pos).source == '()'
 
-          yield range_between(token1.end_pos, token2.begin_pos)
+          range = range_between(token1.end_pos, token2.begin_pos)
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
         end
 
-        def each_missing_space(token1, token2)
+        def correct_missing_space(token1, token2)
           return if can_be_ignored?(token1, token2)
 
-          if token1.left_parens?
-            yield range_between(token2.begin_pos, token2.begin_pos + 1)
-          elsif token2.right_parens?
-            yield range_between(token2.begin_pos, token2.end_pos)
-          end
-        end
+          range = if token1.left_parens?
+                    range_between(token2.begin_pos, token2.begin_pos + 1)
+                  elsif token2.right_parens?
+                    range_between(token2.begin_pos, token2.end_pos)
+                  end
 
-        def same_line?(token1, token2)
-          token1.line == token2.line
+          add_offense(range, message: MSG_SPACE) do |corrector|
+            corrector.insert_before(range, ' ')
+          end
         end
 
         def parens?(token1, token2)
           token1.left_parens? || token2.right_parens?
         end
 
+        def left_parens?(token1, token2)
+          token1.left_parens? && token2.left_parens?
+        end
+
+        def right_parens?(token1, token2)
+          token1.right_parens? && token2.right_parens?
+        end
+
         def can_be_ignored?(token1, token2)
           return true unless parens?(token1, token2)
 
@@ -122,7 +168,7 @@ module RuboCop
           # follows, and that the rules for space inside don't apply.
           return true if token2.comment?
 
-          return true unless same_line?(token1, token2) && !token1.space_after?
+          true unless same_line?(token1, token2) && !token1.space_after?
         end
       end
     end

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

@@ -8,14 +8,31 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #   %i( foo bar baz )
+      #
       #   # good
       #   %i(foo bar baz)
       #
       #   # bad
       #   %w( foo bar baz )
       #
+      #   # good
+      #   %w(foo bar baz)
+      #
       #   # bad
       #   %x(  ls -l )
+      #
+      #   # good
+      #   %x(ls -l)
+      #
+      #   # bad
+      #   %w( )
+      #   %w(
+      #   )
+      #
+      #   # good
+      #   %w()
       class SpaceInsidePercentLiteralDelimiters < Base
         include MatchRange
         include PercentLiteral
@@ -34,11 +51,21 @@ module RuboCop
         end
 
         def on_percent_literal(node)
+          add_offenses_for_blank_spaces(node)
           add_offenses_for_unnecessary_spaces(node)
         end
 
         private
 
+        def add_offenses_for_blank_spaces(node)
+          range = body_range(node)
+          return if range.source.empty? || !range.source.strip.empty?
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+
         def add_offenses_for_unnecessary_spaces(node)
           return unless node.single_line?
 
@@ -54,6 +81,13 @@ module RuboCop
             each_match_range(contents_range(node), regex, &blk)
           end
         end
+
+        def body_range(node)
+          node.source_range.with(
+            begin_pos: node.location.begin.end_pos,
+            end_pos: node.location.end.begin_pos
+          )
+        end
       end
     end
   end

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

@@ -35,7 +35,7 @@ module RuboCop
         def check(node)
           expression = node.source
           op = node.loc.operator.source
-          escaped_op = op.gsub(/\./, '\.')
+          escaped_op = op.gsub('.', '\.')
 
           # account for multiline range literals
           expression.sub!(/#{escaped_op}\n\s*/, op)

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

@@ -38,6 +38,8 @@ module RuboCop
       #   # bad
       #   foo[ ]
       #   foo[     ]
+      #   foo[
+      #   ]
       #
       #   # good
       #   foo[]
@@ -49,6 +51,8 @@ module RuboCop
       #   # bad
       #   foo[]
       #   foo[    ]
+      #   foo[
+      #   ]
       #
       #   # good
       #   foo[ ]
@@ -64,18 +68,18 @@ module RuboCop
         RESTRICT_ON_SEND = %i[[] []=].freeze
 
         def on_send(node)
-          return if node.multiline?
-
           tokens = processed_source.tokens_within(node)
           left_token = left_ref_bracket(node, tokens)
           return unless left_token
 
           right_token = closing_bracket(tokens, left_token)
 
-          if empty_brackets?(left_token, right_token)
+          if empty_brackets?(left_token, right_token, tokens: tokens)
             return empty_offenses(node, left_token, right_token, EMPTY_MSG)
           end
 
+          return if node.multiline?
+
           if style == :no_space
             no_space_offenses(node, left_token, right_token, MSG)
           else
@@ -86,9 +90,9 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          left, right = reference_brackets(node)
+          tokens, left, right = reference_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)
@@ -100,14 +104,14 @@ module RuboCop
         def reference_brackets(node)
           tokens = processed_source.tokens_within(node)
           left = left_ref_bracket(node, tokens)
-          [left, closing_bracket(tokens, left)]
+          [tokens, left, closing_bracket(tokens, left)]
         end
 
         def left_ref_bracket(node, tokens)
           current_token = tokens.reverse.find(&:left_ref_bracket?)
           previous_token = previous_token(current_token)
 
-          if node.method?(:[]=) || previous_token && !previous_token.right_bracket?
+          if node.method?(:[]=) || (previous_token && !previous_token.right_bracket?)
             tokens.find(&:left_ref_bracket?)
           else
             current_token
@@ -118,7 +122,7 @@ module RuboCop
           i = tokens.index(opening_bracket)
           inner_left_brackets_needing_closure = 0
 
-          tokens[i..-1].each do |token|
+          tokens[i..].each do |token|
             inner_left_brackets_needing_closure += 1 if token.left_bracket?
             inner_left_brackets_needing_closure -= 1 if token.right_bracket?
             return token if inner_left_brackets_needing_closure.zero? && token.right_bracket?

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for whitespace within string interpolations.
+      # Checks for whitespace within string interpolations.
       #
       # @example EnforcedStyle: no_space (default)
       #   # bad
@@ -31,13 +31,14 @@ module RuboCop
         def on_interpolation(begin_node)
           return if begin_node.multiline?
 
-          delims = delimiters(begin_node)
-          return if empty_brackets?(*delims)
+          tokens = processed_source.tokens_within(begin_node)
+          left, right = delimiters(begin_node)
+          return if empty_brackets?(left, right, tokens: tokens)
 
           if style == :no_space
-            no_space_offenses(begin_node, *delims, NO_SPACE_MSG)
+            no_space_offenses(begin_node, left, right, NO_SPACE_MSG)
           else
-            space_offenses(begin_node, *delims, SPACE_MSG)
+            space_offenses(begin_node, left, right, SPACE_MSG)
           end
         end