rubocop 1.53.0 → 1.90.0

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

@@ -50,6 +50,20 @@ module RuboCop
       #
       #   # good
       #   a ** b
+      #
+      # @example EnforcedStyleForRationalLiterals: no_space (default)
+      #   # bad
+      #   1 / 48r
+      #
+      #   # good
+      #   1/48r
+      #
+      # @example EnforcedStyleForRationalLiterals: space
+      #   # bad
+      #   1/48r
+      #
+      #   # good
+      #   1 / 48r
       class SpaceAroundOperators < Base
         include PrecedingFollowingAlignment
         include RangeHelp
@@ -64,7 +78,7 @@ module RuboCop
         end
 
         def on_sclass(node)
-          check_operator(:sclass, node.loc.operator, node.source_range)
+          check_operator(:sclass, node.loc.operator, node)
         end
 
         def on_pair(node)
@@ -72,88 +86,104 @@ module RuboCop
 
           return if hash_table_style? && !node.parent.pairs_on_same_line?
 
-          check_operator(:pair, node.loc.operator, node.source_range)
+          check_operator(:pair, node.loc.operator, node)
         end
 
         def on_if(node)
           return unless node.ternary?
 
-          check_operator(:if, node.loc.question, node.if_branch.source_range)
-          check_operator(:if, node.loc.colon, node.else_branch.source_range)
+          check_operator(:if, node.loc.question, node.if_branch)
+          check_operator(:if, node.loc.colon, node.else_branch)
         end
 
         def on_resbody(node)
           return unless node.loc.assoc
 
-          _, variable, = *node
-
-          check_operator(:resbody, node.loc.assoc, variable.source_range)
+          check_operator(:resbody, node.loc.assoc, node.exception_variable)
         end
 
         def on_send(node)
           return if rational_literal?(node)
 
           if node.setter_method?
-            on_special_asgn(node)
+            on_setter_method(node)
           elsif regular_operator?(node)
-            check_operator(:send, node.loc.selector, node.first_argument.source_range)
+            check_operator(:send, node.loc.selector, node.first_argument)
           end
         end
 
         def on_assignment(node)
-          _, rhs, = *node
+          rhs = node.rhs
 
           return unless rhs
 
-          check_operator(:assignment, node.loc.operator, rhs.source_range)
+          type = node.op_asgn_type? ? :special_asgn : :assignment
+          check_operator(type, node.loc.operator, rhs)
         end
 
-        def on_casgn(node)
-          _, _, right, = *node
+        def on_class(node)
+          rhs = node.parent_class
 
-          return unless right
+          return unless rhs
 
-          check_operator(:assignment, node.loc.operator, right.source_range)
+          check_operator(:class, node.loc.operator, rhs)
+        end
+
+        def on_def(node)
+          return unless node.endless?
+
+          check_operator(:assignment, node.loc.assignment, node.body)
         end
 
         def on_binary(node)
-          _, rhs, = *node
+          rhs = node.rhs
 
           return unless rhs
 
-          check_operator(:binary, node.loc.operator, rhs.source_range)
+          check_operator(:binary, node.loc.operator, rhs)
         end
 
-        def on_special_asgn(node)
-          _, _, right, = *node
+        def on_setter_method(node)
+          rhs = node.first_argument
 
-          return unless right
+          return unless rhs
 
-          check_operator(:special_asgn, node.loc.operator, right.source_range)
+          check_operator(:special_asgn, node.loc.operator, node.first_argument)
         end
 
         def on_match_pattern(node)
           return if target_ruby_version < 3.0
 
-          check_operator(:match_pattern, node.loc.operator, node.source_range)
+          check_operator(:match_pattern, node.loc.operator, node)
+        end
+
+        def on_match_alt(node)
+          check_operator(:match_alt, node.loc.operator, node)
+        end
+
+        def on_match_as(node)
+          check_operator(:match_as, node.loc.operator, node)
         end
 
         alias on_or       on_binary
         alias on_and      on_binary
         alias on_lvasgn   on_assignment
+        alias on_casgn    on_assignment
         alias on_masgn    on_assignment
         alias on_ivasgn   on_assignment
         alias on_cvasgn   on_assignment
         alias on_gvasgn   on_assignment
-        alias on_class    on_binary
         alias on_or_asgn  on_assignment
         alias on_and_asgn on_assignment
-        alias on_op_asgn  on_special_asgn
+        alias on_op_asgn  on_assignment
+        alias on_defs     on_def
 
         private
 
         def regular_operator?(send_node)
-          !send_node.unary_operation? && !send_node.dot? && operator_with_regular_syntax?(send_node)
+          return false if send_node.unary_operation? || send_node.dot? || send_node.double_colon?
+
+          operator_with_regular_syntax?(send_node)
         end
 
         def operator_with_regular_syntax?(send_node)
@@ -164,9 +194,12 @@ module RuboCop
           with_space = range_with_surrounding_space(operator)
           return if with_space.source.start_with?("\n")
 
+          comment = processed_source.comment_at_line(operator.line)
+          return if comment && with_space.last_column == comment.loc.column
+
           offense(type, operator, with_space, right_operand) do |msg|
             add_offense(operator, message: msg) do |corrector|
-              autocorrect(corrector, with_space)
+              autocorrect(corrector, with_space, right_operand)
             end
           end
         end
@@ -176,11 +209,19 @@ module RuboCop
           yield msg if msg
         end
 
-        def autocorrect(corrector, range)
-          if range.source.include?('**') && !space_around_exponent_operator?
+        def autocorrect(corrector, range, right_operand)
+          range_source = range.source
+          # Match the operator exactly, not by substring, so compound assignments
+          # like `**=` and `/=` are not mistaken for `**` and `/` (which would drop
+          # the `=` and silently change the program's behavior).
+          operator = range_source.strip
+
+          if operator == '**' && !space_around_exponent_operator?
             corrector.replace(range, '**')
-          elsif range.source.end_with?("\n")
-            corrector.replace(range, " #{range.source.strip}\n")
+          elsif operator == '/' && !space_around_slash_operator?(right_operand)
+            corrector.replace(range, '/')
+          elsif range_source.end_with?("\n")
+            corrector.replace(range, " #{range_source.strip}\n")
           else
             enclose_operator_with_space(corrector, range)
           end
@@ -200,14 +241,14 @@ module RuboCop
         end
 
         def offense_message(type, operator, with_space, right_operand)
-          if should_not_have_surrounding_space?(operator)
+          if should_not_have_surrounding_space?(operator, right_operand)
             return if with_space.is?(operator.source)
 
             "Space around operator `#{operator.source}` detected."
           elsif !/^\s.*\s$/.match?(with_space.source)
             "Surrounding space missing for operator `#{operator.source}`."
           elsif excess_leading_space?(type, operator, with_space) ||
-                excess_trailing_space?(right_operand, with_space)
+                excess_trailing_space?(right_operand.source_range, with_space)
             "Operator `#{operator.source}` should be surrounded " \
               'by a single space.'
           end
@@ -220,12 +261,12 @@ module RuboCop
           return !aligned_with_operator?(operator) unless type == :assignment
 
           token            = Token.new(operator, nil, operator.source)
-          align_preceding  = aligned_with_preceding_assignment(token)
+          align_preceding  = aligned_with_preceding_equals_operator(token)
 
           return false if align_preceding == :yes ||
-                          aligned_with_subsequent_assignment(token) == :none
+                          aligned_with_subsequent_equals_operator(token) == :none
 
-          aligned_with_subsequent_assignment(token) != :yes
+          aligned_with_subsequent_equals_operator(token) != :yes
         end
 
         def excess_trailing_space?(right_operand, with_space)
@@ -238,19 +279,34 @@ module RuboCop
         end
 
         def hash_table_style?
-          align_hash_cop_config && align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
+          return false unless align_hash_cop_config
+
+          enforced_styles = Array(align_hash_cop_config['EnforcedHashRocketStyle'])
+          enforced_styles.include?('table')
         end
 
         def space_around_exponent_operator?
           cop_config['EnforcedStyleForExponentOperator'] == 'space'
         end
 
+        def space_around_slash_operator?(right_operand)
+          return true unless right_operand.rational_type?
+
+          cop_config['EnforcedStyleForRationalLiterals'] == 'space'
+        end
+
         def force_equal_sign_alignment?
           config.for_cop('Layout/ExtraSpacing')['ForceEqualSignAlignment']
         end
 
-        def should_not_have_surrounding_space?(operator)
-          operator.is?('**') ? !space_around_exponent_operator? : false
+        def should_not_have_surrounding_space?(operator, right_operand)
+          if operator.is?('**')
+            !space_around_exponent_operator?
+          elsif operator.is?('/')
+            !space_around_slash_operator?(right_operand)
+          else
+            false
+          end
         end
       end
     end

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

@@ -77,23 +77,33 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
         def check_empty(left_brace, space_plus_brace, used_style)
-          return if style_for_empty_braces == used_style
-
-          config_to_allow_offenses['EnforcedStyleForEmptyBraces'] = used_style.to_s
+          if style_for_empty_braces == used_style
+            handle_different_styles_for_empty_braces(used_style)
+            return
+          elsif !config_to_allow_offenses.key?('Enabled')
+            config_to_allow_offenses['EnforcedStyleForEmptyBraces'] = used_style.to_s
+          end
 
           if style_for_empty_braces == :space
-            add_offense(left_brace, message: MISSING_MSG) do |corrector|
-              autocorrect(corrector, left_brace)
-            end
+            range = left_brace
+            msg = MISSING_MSG
           else
-            space = range_between(space_plus_brace.begin_pos, left_brace.begin_pos)
-            add_offense(space, message: DETECTED_MSG) do |corrector|
-              autocorrect(corrector, space)
-            end
+            range = range_between(space_plus_brace.begin_pos, left_brace.begin_pos)
+            msg = DETECTED_MSG
+          end
+          add_offense(range, message: msg) { |corrector| autocorrect(corrector, range) }
+        end
+
+        def handle_different_styles_for_empty_braces(used_style)
+          if config_to_allow_offenses['EnforcedStyleForEmptyBraces'] &&
+             config_to_allow_offenses['EnforcedStyleForEmptyBraces'].to_sym != used_style
+            config_to_allow_offenses.clear
+            config_to_allow_offenses['Enabled'] = false
           end
         end
 

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Layout
       # Checks for space between the name of a receiver and a left
-      # brackets.
+      # bracket.
       #
       # @example
       #
@@ -22,51 +22,18 @@ module RuboCop
         RESTRICT_ON_SEND = %i[[] []=].freeze
 
         def on_send(node)
-          return unless (first_argument = node.first_argument)
+          return if node.loc.dot
 
-          begin_pos = first_argument.source_range.begin_pos
-          return unless (range = offense_range(node, begin_pos))
+          receiver_end_pos = node.receiver.source_range.end_pos
+          selector_begin_pos = node.loc.selector.begin_pos
+          return if receiver_end_pos >= selector_begin_pos
 
-          register_offense(range)
-        end
-
-        private
+          range = range_between(receiver_end_pos, selector_begin_pos)
 
-        def offense_range(node, begin_pos)
-          if reference_variable_with_brackets?(node)
-            receiver_end_pos = node.receiver.source_range.end_pos
-            selector_begin_pos = node.loc.selector.begin_pos
-            return if receiver_end_pos >= selector_begin_pos
-            return if dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
-
-            range_between(receiver_end_pos, selector_begin_pos)
-          elsif node.method?(:[]=)
-            offense_range_for_assignment(node, begin_pos)
+          add_offense(range) do |corrector|
+            corrector.remove(range)
           end
         end
-
-        def dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
-          return false unless node.loc.respond_to?(:dot) && (dot = node.loc.dot)
-
-          dot.begin_pos == receiver_end_pos && dot.end_pos == selector_begin_pos
-        end
-
-        def offense_range_for_assignment(node, begin_pos)
-          end_pos = node.receiver.source_range.end_pos
-
-          return if begin_pos - end_pos == 1 ||
-                    (range = range_between(end_pos, begin_pos - 1)).source.start_with?('[')
-
-          range
-        end
-
-        def register_offense(range)
-          add_offense(range) { |corrector| corrector.remove(range) }
-        end
-
-        def reference_variable_with_brackets?(node)
-          node.receiver&.variable? && node.method?(:[]) && node.arguments.size == 1
-        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for comma (,) preceded by space.
+      # Checks for comma (`,`) preceded by space.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks for semicolon (;) preceded by space.
+      # Checks for semicolon (`;`) preceded by space.
       #
       # @example
       #   # bad

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

@@ -7,18 +7,18 @@ module RuboCop
       # parenthesis (`(`) in lambda literals.
       #
       # @example EnforcedStyle: require_no_space (default)
-      #     # bad
-      #     a = -> (x, y) { x + y }
+      #   # bad
+      #   a = -> (x, y) { x + y }
       #
-      #     # good
-      #     a = ->(x, y) { x + y }
+      #   # good
+      #   a = ->(x, y) { x + y }
       #
       # @example EnforcedStyle: require_space
-      #     # bad
-      #     a = ->(x, y) { x + y }
+      #   # bad
+      #   a = ->(x, y) { x + y }
       #
-      #     # good
-      #     a = -> (x, y) { x + y }
+      #   # good
+      #   a = -> (x, y) { x + y }
       class SpaceInLambdaLiteral < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
@@ -26,6 +26,7 @@ module RuboCop
 
         MSG_REQUIRE_SPACE = 'Use a space between `->` and `(` in lambda literals.'
         MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and `(` in lambda literals.'
+        RESTRICT_ON_SEND = %i[lambda].freeze
 
         def on_send(node)
           return unless arrow_lambda_with_args?(node)

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

@@ -6,15 +6,19 @@ module RuboCop
       # Checks that brackets used for array literals have or don't have
       # surrounding space depending on configuration.
       #
+      # Array pattern matching is handled in the same way.
+      #
       # @example EnforcedStyle: no_space (default)
       #   # The `no_space` style enforces that array literals have
       #   # no surrounding space.
       #
       #   # bad
       #   array = [ a, b, c, d ]
+      #   array = [ a, [ b, c ]]
       #
       #   # good
       #   array = [a, b, c, d]
+      #   array = [a, [b, c]]
       #
       # @example EnforcedStyle: space
       #   # The `space` style enforces that array literals have
@@ -22,9 +26,11 @@ module RuboCop
       #
       #   # bad
       #   array = [a, b, c, d]
+      #   array = [ a, [ b, c ]]
       #
       #   # good
       #   array = [ a, b, c, d ]
+      #   array = [ a, [ b, c ] ]
       #
       # @example EnforcedStyle: compact
       #   # The `compact` style normally requires a space inside
@@ -32,6 +38,7 @@ module RuboCop
       #   # or right brackets are collapsed together in nested arrays.
       #
       #   # bad
+      #   array = [a, b, c, d]
       #   array = [ a, [ b, c ] ]
       #   array = [
       #     [ a ],
@@ -39,6 +46,7 @@ module RuboCop
       #   ]
       #
       #   # good
+      #   array = [ a, b, c, d ]
       #   array = [ a, [ b, c ]]
       #   array = [[ a ],
       #     [ b, c ]]
@@ -76,22 +84,29 @@ module RuboCop
         EMPTY_MSG = '%<command>s space inside empty array brackets.'
 
         def on_array(node)
-          return unless node.square_brackets?
+          return if node.array_type? && !node.square_brackets?
 
+          node = find_node_with_brackets(node)
           tokens, left, right = array_brackets(node)
+          return unless left && right
 
           if empty_brackets?(left, right, tokens: tokens)
             return empty_offenses(node, left, right, EMPTY_MSG)
           end
 
-          start_ok = next_to_newline?(node, left)
+          start_ok = next_to_newline?(tokens, left)
           end_ok = node.single_line? ? false : end_has_own_line?(right)
 
-          issue_offenses(node, left, right, start_ok, end_ok)
+          issue_offenses(node, tokens, left, right, start_ok, end_ok)
         end
+        alias on_array_pattern on_array
 
         private
 
+        def find_node_with_brackets(node)
+          node.ancestors.find(&:const_pattern_type?) || node
+        end
+
         def autocorrect(corrector, node)
           tokens, left, right = array_brackets(node)
 
@@ -102,14 +117,14 @@ module RuboCop
           elsif style == :space
             SpaceCorrector.add_space(processed_source, corrector, left, right)
           else
-            compact_corrections(corrector, node, left, right)
+            compact_corrections(corrector, tokens, left, right)
           end
         end
 
         def array_brackets(node)
           tokens = processed_source.tokens_within(node)
 
-          left = tokens.find(&:left_array_bracket?)
+          left = tokens.find(&:left_bracket?)
           right = tokens.reverse_each.find(&:right_bracket?)
 
           [tokens, left, right]
@@ -119,8 +134,8 @@ module RuboCop
           cop_config['EnforcedStyleForEmptyBrackets']
         end
 
-        def next_to_newline?(node, token)
-          processed_source.tokens_within(node)[index_for(node, token) + 1].line != token.line
+        def next_to_newline?(tokens, token)
+          tokens[index_for(tokens, token) + 1].line != token.line
         end
 
         def end_has_own_line?(token)
@@ -130,68 +145,65 @@ module RuboCop
           !/\S/.match?(processed_source.lines[line][0..col])
         end
 
-        def index_for(node, token)
-          processed_source.tokens_within(node).index(token)
+        def index_for(tokens, token)
+          tokens.index(token)
         end
 
         def line_and_column_for(token)
           [token.line - 1, token.column - 1]
         end
 
-        def issue_offenses(node, left, right, start_ok, end_ok)
+        # rubocop:disable-next Metrics/ParameterLists
+        def issue_offenses(node, tokens, left, right, start_ok, end_ok)
           case style
           when :no_space
-            start_ok = next_to_comment?(node, left)
+            start_ok = next_to_comment?(tokens, left)
             no_space_offenses(node, left, right, MSG, start_ok: start_ok, end_ok: end_ok)
           when :space
             space_offenses(node, left, right, MSG, start_ok: start_ok, end_ok: end_ok)
           else
-            compact_offenses(node, left, right, start_ok, end_ok)
+            compact_offenses(node, tokens, left, right, start_ok, end_ok)
           end
         end
 
-        def next_to_comment?(node, token)
-          processed_source.tokens_within(node)[index_for(node, token) + 1].comment?
+        def next_to_comment?(tokens, token)
+          tokens[index_for(tokens, token) + 1].comment?
         end
 
-        def compact_offenses(node, left, right, start_ok, end_ok)
-          if qualifies_for_compact?(node, left, side: :left)
+        # rubocop:disable-next Metrics/ParameterLists
+        def compact_offenses(node, tokens, left, right, start_ok, end_ok)
+          if qualifies_for_compact?(tokens, left, side: :left)
             compact_offense(node, left, side: :left)
-          elsif !multi_dimensional_array?(node, left, side: :left)
+          elsif !multi_dimensional_array?(tokens, left, side: :left)
             space_offenses(node, left, nil, MSG, start_ok: start_ok, end_ok: true)
           end
-          if qualifies_for_compact?(node, right)
+
+          if qualifies_for_compact?(tokens, right)
             compact_offense(node, right)
-          elsif !multi_dimensional_array?(node, right)
+          elsif !multi_dimensional_array?(tokens, right)
             space_offenses(node, nil, right, MSG, start_ok: true, end_ok: end_ok)
           end
         end
 
-        def qualifies_for_compact?(node, token, side: :right)
+        def qualifies_for_compact?(tokens, token, side: :right)
           if side == :right
-            multi_dimensional_array?(node, token) && token.space_before?
+            multi_dimensional_array?(tokens, token) && token.space_before?
           else
-            multi_dimensional_array?(node, token, side: :left) && token.space_after?
+            multi_dimensional_array?(tokens, token, side: :left) && token.space_after?
           end
         end
 
-        def multi_dimensional_array?(node, token, side: :right)
+        def multi_dimensional_array?(tokens, token, side: :right)
           offset = side == :right ? -1 : +1
-          i = index_for(node, token) + offset
-          i += offset while processed_source.tokens_within(node)[i].new_line?
+          i = index_for(tokens, token) + offset
+          i += offset while tokens[i].new_line?
           if side == :right
-            processed_source.tokens_within(node)[i].right_bracket?
+            tokens[i].right_bracket?
           else
-            processed_source.tokens_within(node)[i].left_array_bracket?
+            tokens[i].left_bracket?
           end
         end
 
-        def next_to_bracket?(token, side: :right)
-          line_index, col = line_and_column_for(token)
-          line = processed_source.lines[line_index]
-          side == :right ? line[col] == ']' : line[col + 2] == '['
-        end
-
         def compact_offense(node, token, side: :right)
           if side == :right
             space_offense(node, token, :left, MSG, NO_SPACE_COMMAND)
@@ -200,14 +212,14 @@ module RuboCop
           end
         end
 
-        def compact_corrections(corrector, node, left, right)
-          if multi_dimensional_array?(node, left, side: :left)
+        def compact_corrections(corrector, tokens, left, right)
+          if multi_dimensional_array?(tokens, left, side: :left)
             compact(corrector, left, :right)
           elsif !left.space_after?
             corrector.insert_after(left.pos, ' ')
           end
 
-          if multi_dimensional_array?(node, right)
+          if multi_dimensional_array?(tokens, right)
             compact(corrector, right, :left)
           elsif !right.space_before?
             corrector.insert_before(right.pos, ' ')

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

@@ -82,6 +82,10 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Style::BlockDelimiters]
+        end
+
         def on_block(node)
           return if node.keywords?
 
@@ -99,6 +103,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private