rubocop 1.50.2 → 1.62.1

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,14 +86,14 @@ 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)
@@ -87,7 +101,7 @@ module RuboCop
 
           _, variable, = *node
 
-          check_operator(:resbody, node.loc.assoc, variable.source_range)
+          check_operator(:resbody, node.loc.assoc, variable)
         end
 
         def on_send(node)
@@ -96,7 +110,7 @@ module RuboCop
           if node.setter_method?
             on_special_asgn(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
 
@@ -105,7 +119,7 @@ module RuboCop
 
           return unless rhs
 
-          check_operator(:assignment, node.loc.operator, rhs.source_range)
+          check_operator(:assignment, node.loc.operator, rhs)
         end
 
         def on_casgn(node)
@@ -113,7 +127,7 @@ module RuboCop
 
           return unless right
 
-          check_operator(:assignment, node.loc.operator, right.source_range)
+          check_operator(:assignment, node.loc.operator, right)
         end
 
         def on_binary(node)
@@ -121,7 +135,7 @@ module RuboCop
 
           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)
@@ -129,13 +143,13 @@ module RuboCop
 
           return unless right
 
-          check_operator(:special_asgn, node.loc.operator, right.source_range)
+          check_operator(:special_asgn, node.loc.operator, right)
         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
 
         alias on_or       on_binary
@@ -153,7 +167,9 @@ module RuboCop
         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)
@@ -166,7 +182,7 @@ module RuboCop
 
           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 +192,15 @@ 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
+
+          if range_source.include?('**') && !space_around_exponent_operator?
             corrector.replace(range, '**')
-          elsif range.source.end_with?("\n")
-            corrector.replace(range, " #{range.source.strip}\n")
+          elsif range_source.include?('/') && !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 +220,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
@@ -245,12 +265,24 @@ module RuboCop
           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

@@ -81,19 +81,28 @@ module RuboCop
         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_inside_block_braces.rb

@@ -236,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

@@ -116,7 +116,7 @@ module RuboCop
 
         def incorrect_style_detected(token1, token2,
                                      expect_space, is_empty_braces)
-          brace = (token1.text == '{' ? token1 : token2).pos
+          brace = (token1.left_brace? ? token1 : token2).pos
           range = expect_space ? brace : space_range(brace)
           detected_style = expect_space ? 'no_space' : 'space'
 

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

@@ -168,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?
+          !same_line?(token1, token2) || token1.space_after?
         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/trailing_empty_lines.rb

@@ -51,6 +51,7 @@ module RuboCop
           # there could be good reasons why it needs to end with a certain
           # number of newlines.
           return if ends_in_end?(processed_source)
+          return if end_with_percent_blank_string?(processed_source)
 
           whitespace_at_end = buffer.source[/\s*\Z/]
           blank_lines = whitespace_at_end.count("\n") - 1
@@ -86,6 +87,10 @@ module RuboCop
           extra&.strip&.start_with?('__END__')
         end
 
+        def end_with_percent_blank_string?(processed_source)
+          processed_source.buffer.source.end_with?("%\n\n")
+        end
+
         def message(wanted_blank_lines, blank_lines)
           case blank_lines
           when -1

data/lib/rubocop/cop/lint/ambiguous_block_association.rb

@@ -52,6 +52,8 @@ module RuboCop
       #   expect { do_something }.to not_change { object.attribute }
       #
       class AmbiguousBlockAssociation < Base
+        extend AutoCorrector
+
         include AllowedMethods
         include AllowedPattern
 
@@ -68,7 +70,9 @@ module RuboCop
 
           message = message(node)
 
-          add_offense(node, message: message)
+          add_offense(node, message: message) do |corrector|
+            wrap_in_parentheses(corrector, node)
+          end
         end
         alias on_csend on_send
 
@@ -89,6 +93,14 @@ module RuboCop
 
           format(MSG, param: block_param.source, method: block_param.send_node.source)
         end
+
+        def wrap_in_parentheses(corrector, node)
+          range = node.loc.selector.end.join(node.first_argument.source_range.begin)
+
+          corrector.remove(range)
+          corrector.insert_before(range, '(')
+          corrector.insert_after(node.last_argument, ')')
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -17,24 +17,24 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   if some_var = true
+      #   if some_var = value
       #     do_something
       #   end
       #
       #   # good
-      #   if some_var == true
+      #   if some_var == value
       #     do_something
       #   end
       #
       # @example AllowSafeAssignment: true (default)
       #   # good
-      #   if (some_var = true)
+      #   if (some_var = value)
       #     do_something
       #   end
       #
       # @example AllowSafeAssignment: false
       #   # bad
-      #   if (some_var = true)
+      #   if (some_var = value)
       #     do_something
       #   end
       #

data/lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb

@@ -6,10 +6,10 @@ module RuboCop
       # Checks for places where binary operator has identical operands.
       #
       # It covers arithmetic operators: `-`, `/`, `%`;
-      # comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, `<=`;
+      # comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, ``<=``;
       # bitwise operators: `|`, `^`, `&`;
       # boolean operators: `&&`, `||`
-      # and "spaceship" operator - `<=>`.
+      # and "spaceship" operator - ``<=>``.
       #
       # Simple arithmetic operations are allowed by this cop: `+`, `*`, `**`, `<<` and `>>`.
       # Although these can be rewritten in a different way, it should not be necessary to

data/lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for overwriting an exception with an exception result by use `rescue =>`.
+      # Checks for overwriting an exception with an exception result by use ``rescue =>``.
       #
       # You intended to write as `rescue StandardError`.
       # However, you have written `rescue => StandardError`.

data/lib/rubocop/cop/lint/debugger.rb

@@ -66,12 +66,10 @@ module RuboCop
       #   end
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
+        BLOCK_TYPES = %i[block numblock kwbegin].freeze
 
         def on_send(node)
-          return unless debugger_method?(node)
-
-          # Basically, debugger methods are not used as a method argument without arguments.
-          return if node.arguments.empty? && node.each_ancestor(:send, :csend).any?
+          return if !debugger_method?(node) || assumed_usage_context?(node)
 
           add_offense(node)
         end
@@ -90,11 +88,21 @@ module RuboCop
         end
 
         def debugger_method?(send_node)
-          return if send_node.parent&.send_type? && send_node.parent.receiver == send_node
+          return false if send_node.parent&.send_type? && send_node.parent.receiver == send_node
 
           debugger_methods.include?(chained_method_name(send_node))
         end
 
+        def assumed_usage_context?(node)
+          # Basically, debugger methods are not used as a method argument without arguments.
+          return false unless node.arguments.empty? && node.each_ancestor(:send, :csend).any?
+          return true if assumed_argument?(node)
+
+          node.each_ancestor.none? do |ancestor|
+            BLOCK_TYPES.include?(ancestor.type) || ancestor.lambda_or_proc?
+          end
+        end
+
         def chained_method_name(send_node)
           chained_method_name = send_node.method_name.to_s
           receiver = send_node.receiver
@@ -105,6 +113,12 @@ module RuboCop
           end
           chained_method_name
         end
+
+        def assumed_argument?(node)
+          parent = node.parent
+
+          parent.call_type? || parent.literal? || parent.pair_type?
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/duplicate_hash_key.rb

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Lint
       # Checks for duplicated keys in hash literals.
+      # This cop considers both primitive types and constants for the hash keys.
       #
       # This cop mirrors a warning in Ruby 2.2.
       #
@@ -24,7 +25,7 @@ module RuboCop
         MSG = 'Duplicated key in hash literal.'
 
         def on_hash(node)
-          keys = node.keys.select(&:recursive_basic_literal?)
+          keys = node.keys.select { |key| key.recursive_basic_literal? || key.const_type? }
 
           return unless duplicates?(keys)
 

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -253,7 +253,7 @@ module RuboCop
           # Assume that if a method definition is inside any block call which
           # we can't identify, it could be a DSL
           node.each_ancestor(:block).any? do |ancestor|
-            ancestor.method_name != :class_eval && !ancestor.class_constructor?
+            !ancestor.method?(:class_eval) && !ancestor.class_constructor?
           end
         end
 

data/lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb

@@ -24,6 +24,8 @@ module RuboCop
 
         MSG_REPEATED_ELEMENT = 'Duplicate element inside regexp character class'
 
+        OCTAL_DIGITS_AFTER_ESCAPE = 2
+
         def on_regexp(node)
           each_repeated_character_class_element_loc(node) do |loc|
             add_offense(loc, message: MSG_REPEATED_ELEMENT) do |corrector|
@@ -32,35 +34,57 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def each_repeated_character_class_element_loc(node)
           node.parsed_tree&.each_expression do |expr|
             next if skip_expression?(expr)
 
             seen = Set.new
-            enum = expr.expressions.to_enum
-            expression_count = expr.expressions.count
+            group_expressions(node, expr.expressions) do |group|
+              group_source = group.map(&:to_s).join
 
-            expression_count.times do |current_number|
-              current_child = enum.next
-              next if within_interpolation?(node, current_child)
+              yield source_range(group) if seen.include?(group_source)
 
-              current_child_source = current_child.to_s
-              next_child = enum.peek if current_number + 1 < expression_count
+              seen << group_source
+            end
+          end
+        end
 
-              if seen.include?(current_child_source)
-                next if start_with_escaped_zero_number?(current_child_source, next_child.to_s)
+        private
 
-                yield current_child.expression
-              end
+        def group_expressions(node, expressions)
+          # Create a mutable list to simplify state tracking while we iterate.
+          expressions = expressions.to_a
 
-              seen << current_child_source
-            end
+          until expressions.empty?
+            # With we may need to compose a group of multiple expressions.
+            group = [expressions.shift]
+            next if within_interpolation?(node, group.first)
+
+            # With regexp_parser < 2.7 escaped octal sequences may be up to 3
+            # separate expressions ("\\0", "0", "1").
+            pop_octal_digits(group, expressions) if escaped_octal?(group.first.to_s)
+
+            yield(group)
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-        private
+        def pop_octal_digits(current_child, expressions)
+          OCTAL_DIGITS_AFTER_ESCAPE.times do
+            next_child = expressions.first
+            break unless octal?(next_child.to_s)
+
+            current_child << expressions.shift
+          end
+        end
+
+        def source_range(children)
+          return children.first.expression if children.size == 1
+
+          range_between(
+            children.first.expression.begin_pos,
+            children.last.expression.begin_pos + children.last.to_s.length
+          )
+        end
 
         def skip_expression?(expr)
           expr.type != :set || expr.token == :intersection
@@ -75,9 +99,12 @@ module RuboCop
           interpolation_locs(node).any? { |il| il.overlaps?(parse_tree_child_loc) }
         end
 
-        def start_with_escaped_zero_number?(current_child, next_child)
-          # Represents escaped code from `"\00"` (`"\u0000"`) to `"\07"` (`"\a"`).
-          current_child == '\\0' && next_child.match?(/[0-7]/)
+        def escaped_octal?(string)
+          string.length == 2 && string[0] == '\\' && octal?(string[1])
+        end
+
+        def octal?(char)
+          ('0'..'7').cover?(char)
         end
 
         def interpolation_locs(node)

data/lib/rubocop/cop/lint/empty_block.rb

@@ -5,7 +5,7 @@ module RuboCop
     module Lint
       # Checks for blocks without a body.
       # Such empty blocks are typically an oversight or we should provide a comment
-      # be clearer what we're aiming for.
+      # to clarify what we're aiming for.
       #
       # Empty lambdas and procs are ignored by default.
       #

data/lib/rubocop/cop/lint/empty_conditional_body.rb

@@ -104,7 +104,7 @@ module RuboCop
         def correct_other_branches(corrector, node)
           return unless require_other_branches_correction?(node)
 
-          if node.else_branch&.if_type?
+          if node.else_branch&.if_type? && !node.else_branch.modifier_form?
             # Replace an orphaned `elsif` with `if`
             corrector.replace(node.else_branch.loc.keyword, 'if')
           else

data/lib/rubocop/cop/lint/erb_new_arguments.rb

@@ -3,14 +3,13 @@
 module RuboCop
   module Cop
     module Lint
-      #
-      # This cop emulates the following Ruby warnings in Ruby 2.6.
+      # Emulates the following Ruby warnings in Ruby 2.6.
       #
       # [source,console]
       # ----
-      # % cat example.rb
+      # $ cat example.rb
       # ERB.new('hi', nil, '-', '@output_buffer')
-      # % ruby -rerb example.rb
+      # $ ruby -rerb example.rb
       # example.rb:1: warning: Passing safe_level with the 2nd argument of ERB.new is
       # deprecated. Do not use it, and specify other arguments as keyword arguments.
       # example.rb:1: warning: Passing trim_mode with the 3rd argument of ERB.new is
@@ -107,7 +106,7 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          str_arg = node.arguments[0].source
+          str_arg = node.first_argument.source
 
           kwargs = build_kwargs(node)
           overridden_kwargs = override_by_legacy_args(kwargs, node)
@@ -122,11 +121,11 @@ module RuboCop
         end
 
         def build_kwargs(node)
-          return [nil, nil] unless node.arguments.last.hash_type?
+          return [nil, nil] unless node.last_argument.hash_type?
 
           trim_mode_arg, eoutvar_arg = nil
 
-          node.arguments.last.pairs.each do |pair|
+          node.last_argument.pairs.each do |pair|
             case pair.key.source
             when 'trim_mode'
               trim_mode_arg = "trim_mode: #{pair.value.source}"

data/lib/rubocop/cop/lint/float_comparison.rb

@@ -18,6 +18,10 @@ module RuboCop
       #   # good - using BigDecimal
       #   x.to_d == 0.1.to_d
       #
+      #  # good - comparing against zero
+      #   x == 0.0
+      #   x != 0.0
+      #
       #   # good
       #   (x - 0.1).abs < Float::EPSILON
       #
@@ -39,6 +43,8 @@ module RuboCop
 
         def on_send(node)
           lhs, _method, rhs = *node
+          return if literal_zero?(lhs) || literal_zero?(rhs)
+
           add_offense(node) if float?(lhs) || float?(rhs)
         end
 
@@ -59,6 +65,10 @@ module RuboCop
           end
         end
 
+        def literal_zero?(node)
+          node&.numeric_type? && node.value.zero?
+        end
+
         # rubocop:disable Metrics/PerceivedComplexity
         def check_send(node)
           if node.arithmetic_operation?

data/lib/rubocop/cop/lint/hash_compare_by_identity.rb

@@ -35,12 +35,13 @@ module RuboCop
 
         # @!method id_as_hash_key?(node)
         def_node_matcher :id_as_hash_key?, <<~PATTERN
-          (send _ {:key? :has_key? :fetch :[] :[]=} (send _ :object_id) ...)
+          (call _ {:key? :has_key? :fetch :[] :[]=} (send _ :object_id) ...)
         PATTERN
 
         def on_send(node)
           add_offense(node) if id_as_hash_key?(node)
         end
+        alias on_csend on_send
       end
     end
   end

data/lib/rubocop/cop/lint/heredoc_method_call_position.rb

@@ -65,7 +65,7 @@ module RuboCop
         end
 
         def send_node?(node)
-          return nil unless node
+          return false unless node
 
           node.call_type?
         end