rubocop 1.50.2 → 1.59.0

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

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/it_without_arguments_in_block.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Emulates the following Ruby warning in Ruby 3.3.
+      #
+      # [source,ruby]
+      # ----
+      # $ ruby -e '0.times { it }'
+      # -e:1: warning: `it` calls without arguments will refer to the first block param in Ruby 3.4;
+      # use it() or self.it
+      # ----
+      #
+      # `it` calls without arguments will refer to the first block param in Ruby 3.4.
+      # So use `it()` or `self.it` to ensure compatibility.
+      #
+      # @example
+      #
+      #   # bad
+      #   do_something { it }
+      #
+      #   # good
+      #   do_something { it() }
+      #   do_something { self.it }
+      #
+      class ItWithoutArgumentsInBlock < Base
+        include NodePattern::Macros
+
+        MSG = '`it` calls without arguments will refer to the first block param in Ruby 3.4; ' \
+              'use `it()` or `self.it`.'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless (body = node.body)
+          return unless node.arguments.empty_and_without_delimiters?
+
+          if body.send_type? && deprecated_it_method?(body)
+            add_offense(body)
+          else
+            body.each_descendant(:send).each do |send_node|
+              next unless deprecated_it_method?(send_node)
+
+              add_offense(send_node)
+            end
+          end
+        end
+
+        def deprecated_it_method?(node)
+          return false unless node.method?(:it)
+
+          !node.receiver && node.arguments.empty? && !node.parenthesized? && !node.block_literal?
+        end
+      end
+    end
+  end
+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/literal_assignment_in_condition.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for literal assignments in the conditions of `if`, `while`, and `until`.
+      # It emulates the following Ruby warning:
+      #
+      # [source,console]
+      # ----
+      # $ ruby -we 'if x = true; end'
+      # -e:1: warning: found `= literal' in conditional, should be ==
+      # ----
+      #
+      # As a lint cop, it cannot be determined if `==` is appropriate as intended,
+      # therefore this cop does not provide autocorrection.
+      #
+      # @example
+      #
+      #   # bad
+      #   if x = 42
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if x == 42
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if x = y
+      #     do_something
+      #   end
+      #
+      class LiteralAssignmentInCondition < Base
+        MSG = "Don't use literal assignment `= %<literal>s` in conditional, " \
+              'should be `==` or non-literal operand.'
+
+        def on_if(node)
+          traverse_node(node.condition) do |asgn_node|
+            next unless asgn_node.loc.operator
+
+            rhs = asgn_node.to_a.last
+            next if !forbidden_literal?(rhs) || parallel_assignment_with_splat_operator?(rhs)
+
+            range = offense_range(asgn_node, rhs)
+
+            add_offense(range, message: format(MSG, literal: rhs.source))
+          end
+        end
+        alias on_while on_if
+        alias on_until on_if
+
+        private
+
+        def traverse_node(node, &block)
+          yield node if AST::Node::EQUALS_ASSIGNMENTS.include?(node.type)
+
+          node.each_child_node { |child| traverse_node(child, &block) }
+        end
+
+        def forbidden_literal?(node)
+          return false if node.dstr_type? || node.xstr_type?
+
+          node.respond_to?(:literal?) && node.literal?
+        end
+
+        def parallel_assignment_with_splat_operator?(node)
+          node.array_type? && node.values.first&.splat_type?
+        end
+
+        def offense_range(asgn_node, rhs)
+          asgn_node.loc.operator.join(rhs.source_range.end)
+        end
+      end
+    end
+  end
+end

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

@@ -34,7 +34,7 @@ module RuboCop
           # interpolation should not be removed if the expanded value
           # contains a space character.
           expanded_value = autocorrected_value(final_node)
-          return if in_array_percent_literal?(begin_node) && /\s/.match?(expanded_value)
+          return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(expanded_value)
 
           add_offense(final_node) do |corrector|
             return if final_node.dstr_type? # nested, fixed in next iteration

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 != :literal
+          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/next_without_accumulator.rb

@@ -34,35 +34,20 @@ module RuboCop
             add_offense(void_next) if void_next
           end
         end
-
-        def on_numblock(node)
-          on_numblock_body_of_reduce(node) do |body|
-            void_next = body.each_node(:next).find do |n|
-              n.children.empty? && parent_numblock_node(n) == node
-            end
-
-            add_offense(void_next) if void_next
-          end
-        end
+        alias on_numblock on_block
 
         private
 
         # @!method on_block_body_of_reduce(node)
         def_node_matcher :on_block_body_of_reduce, <<~PATTERN
-          (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
-        PATTERN
-
-        # @!method on_numblock_body_of_reduce(node)
-        def_node_matcher :on_numblock_body_of_reduce, <<~PATTERN
-          (numblock (send _recv {:reduce :inject} !sym) _argscount $(begin ...))
+          {
+            (block (call _recv {:reduce :inject} !sym) _blockargs $(begin ...))
+            (numblock (call _recv {:reduce :inject} !sym) _argscount $(begin ...))
+          }
         PATTERN
 
         def parent_block_node(node)
-          node.each_ancestor(:block).first
-        end
-
-        def parent_numblock_node(node)
-          node.each_ancestor(:numblock).first
+          node.each_ancestor(:block, :numblock).first
         end
       end
     end