rubocop 1.69.0 → 1.76.1

data/lib/rubocop/cop/style/class_and_module_children.rb

@@ -3,14 +3,26 @@
 module RuboCop
   module Cop
     module Style
-      # Checks the style of children definitions at classes and
-      # modules. Basically there are two different styles:
+      # Checks that namespaced classes and modules are defined with a consistent style.
+      #
+      # With `nested` style, classes and modules should be defined separately (one constant
+      # on each line, without `::`). With `compact` style, classes and modules should be
+      # defined with fully qualified names (using `::` for namespaces).
+      #
+      # NOTE: The style chosen will affect `Module.nesting` for the class or module. Using
+      # `nested` style will result in each level being added, whereas `compact` style will
+      # only include the fully qualified class or module name.
+      #
+      # By default, `EnforcedStyle` applies to both classes and modules. If desired, separate
+      # styles can be defined for classes and modules by using `EnforcedStyleForClasses` and
+      # `EnforcedStyleForModules` respectively. If not set, or set to nil, the `EnforcedStyle`
+      # value will be used.
       #
       # @safety
       #   Autocorrection is unsafe.
       #
-      #   Moving from compact to nested children requires knowledge of whether the
-      #   outer parent is a module or a class. Moving from nested to compact requires
+      #   Moving from `compact` to `nested` children requires knowledge of whether the
+      #   outer parent is a module or a class. Moving from `nested` to `compact` requires
       #   verification that the outer parent is defined elsewhere. RuboCop does not
       #   have the knowledge to perform either operation safely and thus requires
       #   manual oversight.
@@ -42,16 +54,18 @@ module RuboCop
         def on_class(node)
           return if node.parent_class && style != :nested
 
-          check_style(node, node.body)
+          check_style(node, node.body, style_for_classes)
         end
 
         def on_module(node)
-          check_style(node, node.body)
+          check_style(node, node.body, style_for_modules)
         end
 
         private
 
         def nest_or_compact(corrector, node)
+          style = node.class_type? ? style_for_classes : style_for_modules
+
           if style == :nested
             nest_definition(corrector, node)
           else
@@ -117,18 +131,27 @@ module RuboCop
             "#{node.body.children.first.const_name}"
         end
 
+        # rubocop:disable Metrics/AbcSize
         def remove_end(corrector, body)
-          remove_begin_pos = body.loc.end.begin_pos - leading_spaces(body).size
+          remove_begin_pos = if same_line?(body.loc.name, body.loc.end)
+                               body.loc.name.end_pos
+                             else
+                               body.loc.end.begin_pos - leading_spaces(body).size
+                             end
           adjustment = processed_source.raw_source[remove_begin_pos] == ';' ? 0 : 1
           range = range_between(remove_begin_pos, body.loc.end.end_pos + adjustment)
 
           corrector.remove(range)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def unindent(corrector, node)
-          return if node.body.children.last.nil?
+          return unless node.body.children.last
 
-          column_delta = configured_indentation_width - leading_spaces(node.body.children.last).size
+          last_child_leading_spaces = leading_spaces(node.body.children.last)
+          return if spaces_size(leading_spaces(node)) == spaces_size(last_child_leading_spaces)
+
+          column_delta = configured_indentation_width - spaces_size(last_child_leading_spaces)
           return if column_delta.zero?
 
           AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
@@ -138,7 +161,17 @@ module RuboCop
           node.source_range.source_line[/\A\s*/]
         end
 
-        def check_style(node, body)
+        def spaces_size(spaces_string)
+          mapping = { "\t" => tab_indentation_width }
+          spaces_string.chars.sum { |character| mapping.fetch(character, 1) }
+        end
+
+        def tab_indentation_width
+          config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
+            configured_indentation_width
+        end
+
+        def check_style(node, body, style)
           return if node.identifier.namespace&.cbase_type?
 
           if style == :nested
@@ -158,7 +191,7 @@ module RuboCop
 
         def check_compact_style(node, body)
           parent = node.parent
-          return if parent&.class_type? || parent&.module_type?
+          return if parent&.type?(:class, :module)
 
           return unless needs_compacting?(body)
 
@@ -180,6 +213,14 @@ module RuboCop
         def compact_node_name?(node)
           node.identifier.source.include?('::')
         end
+
+        def style_for_classes
+          cop_config['EnforcedStyleForClasses'] || style
+        end
+
+        def style_for_modules
+          cop_config['EnforcedStyleForModules'] || style
+        end
       end
     end
   end

data/lib/rubocop/cop/style/class_equality_comparison.rb

@@ -68,7 +68,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          def_node = node.each_ancestor(:def, :defs).first
+          def_node = node.each_ancestor(:any_def).first
           return if def_node &&
                     (allowed_method?(def_node.method_name) ||
                     matches_allowed_pattern?(def_node.method_name))

data/lib/rubocop/cop/style/collection_methods.rb

@@ -49,14 +49,15 @@ module RuboCop
         def on_block(node)
           check_method_node(node.send_node)
         end
-
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_send(node)
           return unless implicit_block?(node)
 
           check_method_node(node)
         end
+        alias on_csend on_send
 
         private
 

data/lib/rubocop/cop/style/combinable_defined.rb

@@ -55,7 +55,7 @@ module RuboCop
         def defined_calls(nodes)
           nodes.filter_map do |defined_node|
             subject = defined_node.first_argument
-            subject if subject.const_type? || subject.call_type?
+            subject if subject.type?(:const, :call)
           end
         end
 

data/lib/rubocop/cop/style/combinable_loops.rb

@@ -80,6 +80,7 @@ module RuboCop
         # rubocop:enable Metrics/CyclomaticComplexity
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_for(node)
           return unless node.parent&.begin_type?
@@ -98,7 +99,7 @@ module RuboCop
         end
 
         def same_collection_looping_block?(node, sibling)
-          return false if sibling.nil? || (!sibling.block_type? && !sibling.numblock_type?)
+          return false if sibling.nil? || !sibling.any_block_type?
 
           sibling.method?(node.method_name) &&
             sibling.receiver == node.receiver &&
@@ -118,7 +119,7 @@ module RuboCop
 
         def correct_end_of_block(corrector, node)
           return unless node.left_sibling.respond_to?(:braces?)
-          return if node.right_sibling&.block_type? || node.right_sibling&.numblock_type?
+          return if node.right_sibling&.any_block_type?
 
           end_of_block = node.left_sibling.braces? ? '}' : ' end'
           corrector.remove(node.loc.end)

data/lib/rubocop/cop/style/command_literal.rb

@@ -173,7 +173,7 @@ module RuboCop
         end
 
         def preferred_delimiters_config
-          config.for_cop('Style/PercentLiteralDelimiters') ['PreferredDelimiters']
+          config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']
         end
       end
     end

data/lib/rubocop/cop/style/commented_keyword.rb

@@ -9,8 +9,8 @@ module RuboCop
       # These keywords are: `class`, `module`, `def`, `begin`, `end`.
       #
       # Note that some comments
-      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
-      # and RBS::Inline annotation comments are allowed.
+      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`),
+      # RBS::Inline annotation, and Steep annotation (`steep:ignore`) are allowed.
       #
       # Autocorrection removes comments from `end` keyword and keeps comments
       # for `class`, `module`, `def` and `begin` above the keyword.
@@ -57,8 +57,10 @@ module RuboCop
 
         REGEXP = /(?<keyword>\S+).*#/.freeze
 
-        SUBCLASS_DEFINITION = /\A\s*class\s+\w+\s*<\s*\w+/.freeze
-        METHOD_DEFINITION = /\A\s*def\s/.freeze
+        SUBCLASS_DEFINITION = /\A\s*class\s+(\w|::)+\s*<\s*(\w|::)+/.freeze
+        METHOD_OR_END_DEFINITIONS = /\A\s*(def\s|end)/.freeze
+
+        STEEP_REGEXP = /#\ssteep:ignore(\s|\z)/.freeze
 
         def on_new_investigation
           processed_source.comments.each do |comment|
@@ -86,6 +88,7 @@ module RuboCop
         def offensive?(comment)
           line = source_line(comment)
           return false if rbs_inline_annotation?(line, comment)
+          return false if steep_annotation?(comment)
 
           KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
             ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
@@ -99,12 +102,16 @@ module RuboCop
           case line
           when SUBCLASS_DEFINITION
             comment.text.start_with?(/#\[.+\]/)
-          when METHOD_DEFINITION
+          when METHOD_OR_END_DEFINITIONS
             comment.text.start_with?('#:')
           else
             false
           end
         end
+
+        def steep_annotation?(comment)
+          comment.text.match?(STEEP_REGEXP)
+        end
       end
     end
   end

data/lib/rubocop/cop/style/comparable_between.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for logical comparison which can be replaced with `Comparable#between?`.
+      #
+      # NOTE: `Comparable#between?` is on average slightly slower than logical comparison,
+      # although the difference generally isn't observable. If you require maximum
+      # performance, consider using logical comparison.
+      #
+      # @safety
+      #   This cop is unsafe because the receiver may not respond to `between?`.
+      #
+      # @example
+      #
+      #   # bad
+      #   x >= min && x <= max
+      #
+      #   # bad
+      #   x <= max && x >= min
+      #
+      #   # good
+      #   x.between?(min, max)
+      #
+      class ComparableBetween < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `%<prefer>s` over logical comparison.'
+
+        # @!method logical_comparison_between_by_min_first?(node)
+        def_node_matcher :logical_comparison_between_by_min_first?, <<~PATTERN
+          (and
+            (send
+              {$_value :>= $_min | $_min :<= $_value})
+            (send
+              {$_value :<= $_max | $_max :>= $_value}))
+        PATTERN
+
+        # @!method logical_comparison_between_by_max_first?(node)
+        def_node_matcher :logical_comparison_between_by_max_first?, <<~PATTERN
+          (and
+            (send
+              {$_value :<= $_max | $_max :>= $_value})
+            (send
+              {$_value :>= $_min | $_min :<= $_value}))
+        PATTERN
+
+        def on_and(node)
+          logical_comparison_between_by_min_first?(node) do |*args|
+            min_and_value, max_and_value = args.each_slice(2).to_a
+
+            register_offense(node, min_and_value, max_and_value)
+          end
+
+          logical_comparison_between_by_max_first?(node) do |*args|
+            max_and_value, min_and_value = args.each_slice(2).to_a
+
+            register_offense(node, min_and_value, max_and_value)
+          end
+        end
+
+        private
+
+        def register_offense(node, min_and_value, max_and_value)
+          value = (min_and_value & max_and_value).first
+          min = min_and_value.find { _1 != value } || value
+          max = max_and_value.find { _1 != value } || value
+
+          prefer = "#{value.source}.between?(#{min.source}, #{max.source})"
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/concat_array_literals.rb

@@ -86,7 +86,7 @@ module RuboCop
 
         def percent_literals_includes_only_basic_literals?(node)
           node.arguments.select(&:percent_literal?).all? do |arg|
-            arg.children.all? { |child| child.str_type? || child.sym_type? }
+            arg.children.all? { |child| child.type?(:str, :sym) }
           end
         end
       end

data/lib/rubocop/cop/style/conditional_assignment.rb

@@ -107,7 +107,7 @@ module RuboCop
           parent = node.parent
           return true unless parent
 
-          !(parent.mlhs_type? || parent.resbody_type?)
+          !parent.type?(:mlhs, :resbody)
         end
       end
 
@@ -309,11 +309,12 @@ module RuboCop
         end
 
         def allowed_single_line?(branches)
-          single_line_conditions_only? && branches.any?(&:begin_type?)
+          single_line_conditions_only? && branches.compact.any?(&:begin_type?)
         end
 
         def assignment_node(node)
           assignment = node.send_type? ? node.last_argument : node.expression
+          return unless assignment
 
           # ignore pseudo-assignments without rhs in for nodes
           return if node.parent&.for_type?
@@ -326,7 +327,7 @@ module RuboCop
         end
 
         def move_assignment_outside_condition(corrector, node)
-          if node.case_type? || node.case_match_type?
+          if node.type?(:case, :case_match)
             CaseCorrector.correct(corrector, self, node)
           elsif node.ternary?
             TernaryCorrector.correct(corrector, node)
@@ -340,7 +341,7 @@ module RuboCop
 
           if ternary_condition?(condition)
             TernaryCorrector.move_assignment_inside_condition(corrector, node)
-          elsif condition.case_type? || condition.case_match_type?
+          elsif condition.type?(:case, :case_match)
             CaseCorrector.move_assignment_inside_condition(corrector, node)
           elsif condition.if_type?
             IfCorrector.move_assignment_inside_condition(corrector, node)
@@ -436,17 +437,28 @@ module RuboCop
       # Helper module to provide common methods to ConditionalAssignment
       # correctors
       module ConditionalCorrectorHelper
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         def remove_whitespace_in_branches(corrector, branch, condition, column)
           branch.each_node do |child|
             next if child.source_range.nil?
+            next if child.parent.dstr_type?
 
             white_space = white_space_range(child, column)
             corrector.remove(white_space) if white_space.source.strip.empty?
           end
 
-          [condition.loc.else, condition.loc.end].each do |loc|
-            corrector.remove_preceding(loc, loc.column - column)
+          if condition.loc.else && !same_line?(condition.else_branch, condition)
+            corrector.remove_preceding(condition.loc.else, condition.loc.else.column - column)
           end
+
+          return unless condition.loc.end && !same_line?(condition.loc.end, condition)
+
+          corrector.remove_preceding(condition.loc.end, condition.loc.end.column - column)
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+        def same_line?(node1, node2)
+          RuboCop::Cop::Util.same_line?(node1, node2)
         end
 
         def white_space_range(node, column)
@@ -593,6 +605,8 @@ module RuboCop
 
             return unless (branch_else = branch.parent.loc.else)
 
+            return if same_line?(branch_else, condition)
+
             corrector.remove_preceding(branch_else, branch_else.column - column)
           end
         end

data/lib/rubocop/cop/style/data_inheritance.rb

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Checks for inheritance from `Data.define` to avoid creating the anonymous parent class.
+      # Inheriting from `Data.define` adds a superfluous level in inheritance tree.
       #
       # @safety
       #   Autocorrection is unsafe because it will change the inheritance
@@ -17,12 +18,18 @@ module RuboCop
       #     end
       #   end
       #
+      #   Person.ancestors
+      #   # => [Person, #<Class:0x000000010b4e14a0>, Data, (...)]
+      #
       #   # good
       #   Person = Data.define(:first_name, :last_name) do
       #     def age
       #       42
       #     end
       #   end
+      #
+      #   Person.ancestors
+      #   # => [Person, Data, (...)]
       class DataInheritance < Base
         include RangeHelp
         extend AutoCorrector

data/lib/rubocop/cop/style/def_with_parentheses.rb

@@ -25,8 +25,9 @@ module RuboCop
       #   # good
       #   def foo = do_something
       #
-      #   # good (without parentheses it's a syntax error)
+      #   # good - without parentheses it's a syntax error
       #   def foo() do_something end
+      #   def foo()=do_something
       #
       #   # bad
       #   def Baz.foo()
@@ -38,19 +39,31 @@ module RuboCop
       #     do_something
       #   end
       class DefWithParentheses < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = "Omit the parentheses in defs when the method doesn't accept any arguments."
 
         def on_def(node)
-          return if node.single_line? && !node.endless?
-          return unless !node.arguments? && (node_arguments = node.arguments.source_range)
+          return unless !node.arguments? && (arguments_range = node.arguments.source_range)
+          return if parentheses_required?(node, arguments_range)
 
-          add_offense(node_arguments) do |corrector|
-            corrector.remove(node_arguments)
+          add_offense(arguments_range) do |corrector|
+            corrector.remove(arguments_range)
           end
         end
         alias on_defs on_def
+
+        private
+
+        def parentheses_required?(node, arguments_range)
+          return true if node.single_line? && !node.endless?
+
+          end_pos = arguments_range.end.end_pos
+          token_after_argument = range_between(end_pos, end_pos + 1).source
+
+          token_after_argument == '='
+        end
       end
     end
   end

data/lib/rubocop/cop/style/dig_chain.rb

@@ -24,7 +24,6 @@ module RuboCop
       #
       class DigChain < Base
         extend AutoCorrector
-        include RangeHelp
         include CommentsHelp
         include DigHelp
 
@@ -49,17 +48,17 @@ module RuboCop
         # Walk up the method chain while the receiver is `dig` with arguments.
         def inspect_chain(node)
           arguments = node.arguments.dup
-          end_pos = node.source_range.end_pos
+          end_range = node.source_range.end
 
-          while dig?((node = node.receiver))
-            begin_pos = node.loc.dot ? node.loc.dot.begin_pos + 1 : 0
+          while dig?(node = node.receiver)
+            begin_range = node.loc.selector
             arguments.unshift(*node.arguments)
             ignore_node(node)
           end
 
-          return unless begin_pos
+          return unless begin_range
 
-          [range_between(begin_pos, end_pos), arguments]
+          [begin_range.join(end_range), arguments]
         end
 
         def invalid_arguments?(arguments)

data/lib/rubocop/cop/style/documentation.rb

@@ -186,7 +186,7 @@ module RuboCop
         def qualify_const(node)
           return if node.nil?
 
-          if node.cbase_type? || node.self_type? || node.call_type? || node.variable?
+          if node.type?(:cbase, :self, :call) || node.variable?
             node.source
           else
             [qualify_const(node.namespace), node.short_name].compact

data/lib/rubocop/cop/style/double_negation.rb

@@ -93,7 +93,7 @@ module RuboCop
 
           if conditional_node
             double_negative_condition_return_value?(node, last_child, conditional_node)
-          elsif last_child.pair_type? || last_child.hash_type? || last_child.parent.array_type?
+          elsif last_child.type?(:pair, :hash) || last_child.parent.array_type?
             false
           else
             last_child.last_line <= node.last_line
@@ -102,14 +102,14 @@ module RuboCop
 
         def find_def_node_from_ascendant(node)
           return unless (parent = node.parent)
-          return parent if parent.def_type? || parent.defs_type?
+          return parent if parent.any_def_type?
           return node.parent.child_nodes.first if define_method?(parent)
 
           find_def_node_from_ascendant(node.parent)
         end
 
         def define_method?(node)
-          return false unless node.block_type?
+          return false unless node.any_block_type?
 
           child = node.child_nodes.first
           return false unless child.send_type?
@@ -147,7 +147,7 @@ module RuboCop
         def find_parent_not_enumerable(node)
           return unless (parent = node.parent)
 
-          if parent.pair_type? || parent.hash_type? || parent.array_type?
+          if parent.type?(:pair, :hash, :array)
             find_parent_not_enumerable(parent)
           else
             parent

data/lib/rubocop/cop/style/each_for_simple_loop.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Checks for loops which iterate a constant number of times,
-      # using a Range literal and `#each`. This can be done more readably using
+      # using a `Range` literal and `#each`. This can be done more readably using
       # `Integer#times`.
       #
       # This check only applies if the block takes no parameters.
@@ -53,8 +53,7 @@ module RuboCop
           (block
             (call
               (begin
-                (${irange erange}
-                  (int $_) (int $_)))
+                ($range (int $_) (int $_)))
               :each)
             (args ...)
             ...)
@@ -65,8 +64,7 @@ module RuboCop
           (block
             (call
               (begin
-                ({irange erange}
-                  (int 0) (int _)))
+                (range (int 0) (int _)))
               :each)
             (args ...)
             ...)
@@ -77,8 +75,7 @@ module RuboCop
           (block
             (call
               (begin
-                ({irange erange}
-                  (int _) (int _)))
+                (range (int _) (int _)))
               :each)
             (args)
             ...)

data/lib/rubocop/cop/style/each_with_object.rb

@@ -58,7 +58,7 @@ module RuboCop
 
         # @!method each_with_object_block_candidate?(node)
         def_node_matcher :each_with_object_block_candidate?, <<~PATTERN
-          (block $(call _ {:inject :reduce} _) $_ $_)
+          (block $(call _ {:inject :reduce} _) $(args _ _) $_)
         PATTERN
 
         # @!method each_with_object_numblock_candidate?(node)
@@ -71,8 +71,7 @@ module RuboCop
 
           first_arg, second_arg = *node.arguments
 
-          corrector.replace(first_arg, second_arg.source)
-          corrector.replace(second_arg, first_arg.source)
+          corrector.swap(first_arg, second_arg)
 
           if return_value_occupies_whole_line?(return_value)
             corrector.remove(whole_line_expression(return_value))

data/lib/rubocop/cop/style/empty_else.rb

@@ -131,6 +131,8 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant `else`-clause.'
+        NIL_STYLES = %i[nil both].freeze
+        EMPTY_STYLES = %i[empty both].freeze
 
         def on_normal_if_unless(node)
           check(node)
@@ -150,11 +152,11 @@ module RuboCop
         end
 
         def nil_style?
-          style == :nil || style == :both
+          NIL_STYLES.include?(style)
         end
 
         def empty_style?
-          style == :empty || style == :both
+          EMPTY_STYLES.include?(style)
         end
 
         def empty_check(node)

data/lib/rubocop/cop/style/empty_literal.rb

@@ -6,6 +6,10 @@ module RuboCop
       # Checks for the use of a method, the result of which
       # would be a literal, like an empty array, hash, or string.
       #
+      # NOTE: When frozen string literals are enabled, `String.new`
+      # isn't corrected to an empty string since the former is
+      # mutable and the latter would be frozen.
+      #
       # @example
       #   # bad
       #   a = Array.new
@@ -136,7 +140,7 @@ module RuboCop
         def frozen_strings?
           return true if frozen_string_literals_enabled?
 
-          frozen_string_cop_enabled = config.for_cop('Style/FrozenStringLiteralComment')['Enabled']
+          frozen_string_cop_enabled = config.cop_enabled?('Style/FrozenStringLiteralComment')
           frozen_string_cop_enabled &&
             !frozen_string_literals_disabled? &&
             string_literals_frozen_by_default?.nil?