rubocop 1.50.2 → 1.54.1

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

@@ -135,7 +135,8 @@ module RuboCop
           return if nodes.all?(&:single_line?) && cop_config['AllowAdjacentOneLineDefs']
 
           correction_node = nodes.last
-          location = correction_node.loc.keyword.join(correction_node.loc.name)
+
+          location = def_location(correction_node)
           add_offense(location, message: message(correction_node, count: count)) do |corrector|
             autocorrect(corrector, *nodes, count)
           end
@@ -159,10 +160,28 @@ module RuboCop
 
         private
 
+        def def_location(correction_node)
+          if correction_node.block_type?
+            correction_node.source_range.join(correction_node.children.first.source_range)
+          else
+            correction_node.loc.keyword.join(correction_node.loc.name)
+          end
+        end
+
         def candidate?(node)
-          return unless node
+          return false unless node
 
-          method_candidate?(node) || class_candidate?(node) || module_candidate?(node)
+          method_candidate?(node) || class_candidate?(node) || module_candidate?(node) ||
+            macro_candidate?(node)
+        end
+
+        def empty_line_between_macros
+          cop_config.fetch('DefLikeMacros', []).map(&:to_sym)
+        end
+
+        def macro_candidate?(node)
+          node.block_type? && node.children.first.macro? &&
+            empty_line_between_macros.include?(node.children.first.method_name)
         end
 
         def method_candidate?(node)
@@ -226,7 +245,11 @@ module RuboCop
         end
 
         def def_start(node)
-          node.loc.keyword.line
+          if node.block_type? && node.children.first.send_type?
+            node.source_range.line
+          else
+            node.loc.keyword.line
+          end
         end
 
         def def_end(node)

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

@@ -68,6 +68,8 @@ module RuboCop
           check_body(node.body, node.loc.line)
         end
         alias on_defs on_def
+        alias on_block on_def
+        alias on_numblock on_def
 
         def on_kwbegin(node)
           body, = *node

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

@@ -228,9 +228,9 @@ module RuboCop
         end
 
         def find_most_bottom_of_heredoc_end(arguments)
-          arguments.map do |argument|
+          arguments.filter_map do |argument|
             argument.loc.heredoc_end.end_pos if argument.loc.respond_to?(:heredoc_end)
-          end.compact.max
+          end.max
         end
 
         # Internal trailing comma helpers.

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

@@ -76,7 +76,7 @@ module RuboCop
 
         def autocorrect_lambda_for_tabs(corrector, range)
           spaces = ' ' * configured_indentation_width
-          corrector.replace(range, range.source.gsub(/\t/, spaces))
+          corrector.replace(range, range.source.gsub("\t", spaces))
         end
 
         def autocorrect_lambda_for_spaces(corrector, range)

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

@@ -366,10 +366,10 @@ module RuboCop
         end
 
         def starts_with_access_modifier?(body_node)
-          return unless body_node.begin_type?
+          return false unless body_node.begin_type?
 
           starting_node = body_node.children.first
-          return unless starting_node
+          return false unless starting_node
 
           starting_node.send_type? && starting_node.bare_access_modifier?
         end

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

@@ -84,6 +84,8 @@ module RuboCop
           return unless strings_concatenated_with_backslash?(node)
 
           children = node.children
+          return if children.empty?
+
           if style == :aligned && !always_indented?(node)
             check_aligned(children, 1)
           else

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

@@ -99,7 +99,7 @@ module RuboCop
         def suitable_as_single_line?(node)
           !comment_within?(node) &&
             node.each_descendant(:if, :case, :kwbegin, :def).none? &&
-            node.each_descendant(:dstr, :str).none?(&:heredoc?) &&
+            node.each_descendant(:dstr, :str).none? { |n| n.heredoc? || n.value.include?("\n") } &&
             node.each_descendant(:begin).none? { |b| !b.single_line? }
         end
 

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

@@ -24,7 +24,15 @@ module RuboCop
         end
 
         def kind(token)
-          'comma' if token.comma?
+          'comma' if token.comma? && !before_semicolon?(token)
+        end
+
+        private
+
+        def before_semicolon?(token)
+          tokens = processed_source.tokens
+
+          tokens[tokens.index(token) + 1].semicolon?
         end
       end
     end

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

@@ -153,7 +153,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)

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_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/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/debugger.rb

@@ -68,10 +68,7 @@ module RuboCop
         MSG = 'Remove debugger entry point `%<source>s`.'
 
         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 +87,18 @@ 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?
+
+          node.each_ancestor.none?(&:lambda_or_proc?)
+        end
+
         def chained_method_name(send_node)
           chained_method_name = send_node.method_name.to_s
           receiver = send_node.receiver

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_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/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

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

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

@@ -3,7 +3,6 @@
 module RuboCop
   module Cop
     module Lint
-      #
       # Prefer `equal?` over `==` when comparing `object_id`.
       #
       # `Object#equal?` is provided to compare objects for identity, and in contrast

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

@@ -3,8 +3,10 @@
 module RuboCop
   module Cop
     module Lint
+      # Checks for `IO.select` that is incompatible with Fiber Scheduler since Ruby 3.0.
       #
-      # This cop checks for `IO.select` that is incompatible with Fiber Scheduler since Ruby 3.0.
+      # When an array of IO objects waiting for an exception (the third argument of `IO.select`)
+      # is used as an argument, there is no alternative API, so offenses are not registered.
       #
       # NOTE: When the method is successful the return value of `IO.select` is `[[IO]]`,
       # and the return value of `io.wait_readable` and `io.wait_writable` are `self`.
@@ -42,8 +44,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          read, write, _excepts, timeout = *io_select(node)
-          return unless read
+          read, write, excepts, timeout = *io_select(node)
+          return if excepts && !excepts.children.empty?
           return unless scheduler_compatible?(read, write) || scheduler_compatible?(write, read)
 
           preferred = preferred_method(read, write, timeout)

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

@@ -58,6 +58,7 @@ module RuboCop
 
         def on_class(node)
           return unless node.parent_class && exception_class?(node.parent_class)
+          return if inherit_exception_class_with_omitted_namespace?(node)
 
           message = message(node.parent_class)
 
@@ -87,6 +88,14 @@ module RuboCop
           class_node.const_name == 'Exception'
         end
 
+        def inherit_exception_class_with_omitted_namespace?(class_node)
+          return false if class_node.parent_class.namespace&.cbase_type?
+
+          class_node.left_siblings.any? do |sibling|
+            sibling.respond_to?(:identifier) && exception_class?(sibling.identifier)
+          end
+        end
+
         def preferred_base_class
           PREFERRED_BASE_CLASS[style]
         end

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks uses of lambda without a literal block.
       # It emulates the following warning in Ruby 3.0:
       #
-      #   % ruby -vwe 'lambda(&proc {})'
+      #   $ ruby -vwe 'lambda(&proc {})'
       #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
       #   -e:1: warning: lambda without a literal block is deprecated; use the proc without
       #   lambda instead

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

@@ -11,6 +11,16 @@ module RuboCop
       # missing method. In other cases, the theoretical ideal handling could be
       # challenging or verbose for no actual gain.
       #
+      # Autocorrection is not supported because the position of `super` cannot be
+      # determined automatically.
+      #
+      # `Object` and `BasicObject` are allowed by this cop because of their
+      # stateless nature. However, sometimes you might want to allow other parent
+      # classes from this cop, for example in the case of an abstract class that is
+      # not meant to be called with `super`. In those cases, you can use the
+      # `AllowedParentClasses` option to specify which classes should be allowed
+      # *in addition to* `Object` and `BasicObject`.
+      #
       # @example
       #   # bad
       #   class Employee < Person
@@ -57,6 +67,21 @@ module RuboCop
       #     end
       #   end
       #
+      #   # good
+      #   class ClassWithNoParent
+      #     def initialize
+      #       do_something
+      #     end
+      #   end
+      #
+      # @example AllowedParentClasses: [MyAbstractClass]
+      #   # good
+      #   class MyConcreteClass < MyAbstractClass
+      #     def initialize
+      #       do_something
+      #     end
+      #   end
+      #
       class MissingSuper < Base
         CONSTRUCTOR_MSG = 'Call `super` to initialize state of the parent class.'
         CALLBACK_MSG    = 'Call `super` to invoke callback defined in the parent class.'
@@ -100,7 +125,7 @@ module RuboCop
         end
 
         def callback_method_def?(node)
-          return unless CALLBACKS.include?(node.method_name)
+          return false unless CALLBACKS.include?(node.method_name)
 
           node.each_ancestor(:class, :sclass, :module).first
         end
@@ -113,16 +138,20 @@ module RuboCop
           if (block_node = node.each_ancestor(:block, :numblock).first)
             return false unless (super_class = class_new_block(block_node))
 
-            !stateless_class?(super_class)
+            !allowed_class?(super_class)
           elsif (class_node = node.each_ancestor(:class).first)
-            class_node.parent_class && !stateless_class?(class_node.parent_class)
+            class_node.parent_class && !allowed_class?(class_node.parent_class)
           else
             false
           end
         end
 
-        def stateless_class?(node)
-          STATELESS_CLASSES.include?(node.const_name)
+        def allowed_class?(node)
+          allowed_classes.include?(node.const_name)
+        end
+
+        def allowed_classes
+          @allowed_classes ||= STATELESS_CLASSES + cop_config.fetch('AllowedParentClasses', [])
         end
       end
     end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for mixed-case character ranges since they include likely unintended characters.
+      #
+      # Offenses are registered for regexp character classes like `/[A-z]/`
+      # as well as range objects like `('A'..'z')`.
+      #
+      # NOTE: Range objects cannot be autocorrected.
+      #
+      # @safety
+      #   The cop autocorrects regexp character classes
+      #   by replacing one character range with two: `A-z` becomes `A-Za-z`.
+      #   In most cases this is probably what was originally intended
+      #   but it changes the regexp to no longer match symbols it used to include.
+      #   For this reason, this cop's autocorrect is unsafe (it will
+      #   change the behavior of the code).
+      #
+      # @example
+      #
+      #   # bad
+      #   r = /[A-z]/
+      #
+      #   # good
+      #   r = /[A-Za-z]/
+      class MixedCaseRange < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Ranges from upper to lower case ASCII letters may include unintended ' \
+              'characters. Instead of `A-z` (which also includes several symbols) ' \
+              'specify each range individually: `A-Za-z` and individually specify any symbols.'
+        RANGES = [('a'..'z').freeze, ('A'..'Z').freeze].freeze
+
+        def on_irange(node)
+          return unless node.children.compact.all?(&:str_type?)
+
+          range_start, range_end = node.children
+
+          return if range_start.nil? || range_end.nil?
+
+          add_offense(node) if unsafe_range?(range_start.value, range_end.value)
+        end
+        alias on_erange on_irange
+
+        def on_regexp(node)
+          each_unsafe_regexp_range(node) do |loc|
+            add_offense(loc) do |corrector|
+              corrector.replace(loc, rewrite_regexp_range(loc.source))
+            end
+          end
+        end
+
+        def each_unsafe_regexp_range(node)
+          node.parsed_tree&.each_expression do |expr|
+            next if skip_expression?(expr)
+
+            range_pairs(expr).reject do |range_start, range_end|
+              next if skip_range?(range_start, range_end)
+
+              next unless unsafe_range?(range_start.text, range_end.text)
+
+              yield(build_source_range(range_start, range_end))
+            end
+          end
+        end
+
+        private
+
+        def build_source_range(range_start, range_end)
+          range_between(range_start.expression.begin_pos, range_end.expression.end_pos)
+        end
+
+        def range_for(char)
+          RANGES.detect do |range|
+            range.include?(char)
+          end
+        end
+
+        def range_pairs(expr)
+          RuboCop::Cop::Utils::RegexpRanges.new(expr).pairs
+        end
+
+        def unsafe_range?(range_start, range_end)
+          return false if range_start.length != 1 || range_end.length != 1
+
+          range_for(range_start) != range_for(range_end)
+        end
+
+        def skip_expression?(expr)
+          !(expr.type == :set && expr.token == :character)
+        end
+
+        def skip_range?(range_start, range_end)
+          [range_start, range_end].any? do |bound|
+            bound.type == :escape
+          end
+        end
+
+        def rewrite_regexp_range(source)
+          open, close = source.split('-')
+          first = [open, range_for(open).end]
+          second = [range_for(close).begin, close]
+          "#{first.uniq.join('-')}#{second.uniq.join('-')}"
+        end
+      end
+    end
+  end
+end

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

@@ -74,6 +74,7 @@ module RuboCop
         extend AutoCorrector
         include AllowedMethods
         include AllowedPattern
+        include IgnoredNode
 
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",
@@ -116,7 +117,11 @@ module RuboCop
               corrected_method: correct_method(node, receiver)
             )
             add_offense(node, message: message) do |corrector|
+              next if part_of_ignored_node?(node)
+
               corrector.replace(node, correct_method(node, node.receiver))
+
+              ignore_node(node)
             end
           end
         end

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

@@ -6,13 +6,13 @@ module RuboCop
       # Checks for uses of numbered parameter assignment.
       # It emulates the following warning in Ruby 2.7:
       #
-      #   % ruby -ve '_1 = :value'
+      #   $ ruby -ve '_1 = :value'
       #   ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin19]
       #   -e:1: warning: `_1' is reserved for numbered parameter; consider another name
       #
       # Assigning to a numbered parameter (from `_1` to `_9`) causes an error in Ruby 3.0.
       #
-      #   % ruby -ve '_1 = :value'
+      #   $ ruby -ve '_1 = :value'
       #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
       #   -e:1: _1 is reserved for numbered parameter
       #