rubocop 1.67.0 → 1.75.5

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

@@ -183,7 +183,8 @@ module RuboCop
         def on_send(node)
           return unless node.arguments?
           return if node.parenthesized?
-          return if node.operator_method? || node.assignment_method?
+          return if node.assignment_method?
+          return if single_argument_operator_method?(node)
 
           node.arguments.each do |arg|
             get_blocks(arg) do |block|
@@ -194,6 +195,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         def on_block(node)
           return if ignored_node?(node)
@@ -206,6 +208,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -303,13 +306,28 @@ module RuboCop
 
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
           range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
+
+          # It is possible that there is code between the block and the comment
+          # which needs to be preserved and trimmed.
+          pre_comment_range = source_range_before_comment(range, comment)
+
           corrector.remove(range_with_surrounding_space(comment.source_range, side: :right))
-          remove_trailing_whitespace(corrector, range, comment)
-          corrector.insert_after(range, "\n")
+          remove_trailing_whitespace(corrector, pre_comment_range, comment)
+          corrector.insert_after(pre_comment_range, "\n")
 
           corrector.insert_before(block_node, "#{comment.text}\n")
         end
 
+        def source_range_before_comment(range, comment)
+          range = range.end.join(comment.source_range.begin)
+
+          # End the range before any whitespace that precedes the comment
+          trailing_whitespace_count = range.source[/\s+\z/]&.length
+          range = range.adjust(end_pos: -trailing_whitespace_count) if trailing_whitespace_count
+
+          range
+        end
+
         def end_of_chain(node)
           return end_of_chain(node.block_node) if with_block?(node)
           return node unless node.chained?
@@ -327,16 +345,23 @@ module RuboCop
           node.respond_to?(:block_node) && node.block_node
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def get_blocks(node, &block)
           case node.type
-          when :block, :numblock
+          when :block, :numblock, :itblock
             yield node
-          when :send
+          when :send, :csend
+            # When a method has an argument which is another method with a block,
+            # that block needs braces, otherwise a syntax error will be introduced
+            # for subsequent arguments.
+            # Additionally, even without additional arguments, changing `{...}` to
+            # `do...end` will change the binding of the block to the outer method.
             get_blocks(node.receiver, &block) if node.receiver
+            node.arguments.each { |argument| get_blocks(argument, &block) }
           when :hash
             # A hash which is passed as method argument may have no braces
             # In that case, one of the K/V pairs could contain a block node
-            # which could change in meaning if do...end replaced {...}
+            # which could change in meaning if `do...end` is replaced with `{...}`
             return if node.braces?
 
             node.each_child_node { |child| get_blocks(child, &block) }
@@ -344,10 +369,10 @@ module RuboCop
             node.each_child_node { |child| get_blocks(child, &block) }
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def proper_block_style?(node)
-          return true if require_braces?(node) || require_do_end?(node)
+          return true if require_do_end?(node)
           return special_method_proper_block_style?(node) if special_method?(node.method_name)
 
           case style
@@ -357,15 +382,6 @@ module RuboCop
           when :always_braces       then braces_style?(node)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
-
-        def require_braces?(node)
-          return false unless node.braces?
-
-          node.each_ancestor(:send).any? do |send|
-            send.arithmetic_operation? && node.source_range.end_pos < send.loc.selector.begin_pos
-          end
-        end
 
         def require_do_end?(node)
           return false if node.braces? || node.multiline?
@@ -459,18 +475,14 @@ module RuboCop
         end
 
         def return_value_of_scope?(node)
-          return false unless node.parent
+          return false unless (parent = node.parent)
 
-          conditional?(node.parent) || array_or_range?(node.parent) ||
-            node.parent.children.last == node
-        end
-
-        def conditional?(node)
-          node.if_type? || node.or_type? || node.and_type?
+          parent.conditional? || parent.operator_keyword? || array_or_range?(parent) ||
+            parent.children.last == node
         end
 
         def array_or_range?(node)
-          node.array_type? || node.range_type?
+          node.type?(:array, :range)
         end
 
         def begin_required?(block_node)
@@ -478,6 +490,12 @@ module RuboCop
           # `begin`...`end` when changing `do-end` to `{}`.
           block_node.each_child_node(:rescue, :ensure).any? && !block_node.single_line?
         end
+
+        def single_argument_operator_method?(node)
+          return false unless node.operator_method?
+
+          node.arguments.one? && node.first_argument.block_type?
+        end
       end
     end
   end

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

@@ -106,7 +106,7 @@ module RuboCop
           when :or
             find_target(node.lhs)
           when :match_with_lvasgn
-            lhs, rhs = *node
+            lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
             if lhs.regexp_type?
               rhs
             elsif rhs.regexp_type?
@@ -172,7 +172,7 @@ module RuboCop
               return collect_conditions(node.lhs, target, conditions) &&
                      collect_conditions(node.rhs, target, conditions)
             when :match_with_lvasgn
-              lhs, rhs = *node
+              lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
               condition_from_binary_op(lhs, rhs, target)
             when :send
               condition_from_send_node(node, target)
@@ -191,8 +191,7 @@ module RuboCop
           when :=~, :match, :match?
             condition_from_match_node(node, target)
           when :===
-            lhs, _method, rhs = *node
-            lhs if rhs == target
+            node.receiver if node.first_argument == target
           when :include?, :cover?
             condition_from_include_or_cover_node(node, target)
           end
@@ -200,14 +199,12 @@ module RuboCop
         # rubocop:enable Metrics/CyclomaticComplexity
 
         def condition_from_equality_node(node, target)
-          lhs, _method, rhs = *node
-          condition = condition_from_binary_op(lhs, rhs, target)
+          condition = condition_from_binary_op(node.receiver, node.first_argument, target)
           condition if condition && !class_reference?(condition)
         end
 
         def condition_from_match_node(node, target)
-          lhs, _method, rhs = *node
-          condition_from_binary_op(lhs, rhs, target)
+          condition_from_binary_op(node.receiver, node.first_argument, target)
         end
 
         def condition_from_include_or_cover_node(node, target)
@@ -263,11 +260,11 @@ module RuboCop
         def regexp_with_working_captures?(node)
           case node.type
           when :match_with_lvasgn
-            lhs, _rhs = *node
+            lhs, _rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
             node.loc.selector.source == '=~' && regexp_with_named_captures?(lhs)
           when :send
-            lhs, method, rhs = *node
-            method == :match && [lhs, rhs].any? { |n| regexp_with_named_captures?(n) }
+            node.method?(:match) &&
+              [node.receiver, node.first_argument].any? { |n| regexp_with_named_captures?(n) }
           end
         end
 

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for multiple `defined?` calls joined by `&&` that can be combined
+      # into a single `defined?`.
+      #
+      # When checking that a nested constant or chained method is defined, it is
+      # not necessary to check each ancestor or component of the chain.
+      #
+      # @example
+      #   # bad
+      #   defined?(Foo) && defined?(Foo::Bar) && defined?(Foo::Bar::Baz)
+      #
+      #   # good
+      #   defined?(Foo::Bar::Baz)
+      #
+      #   # bad
+      #   defined?(foo) && defined?(foo.bar) && defined?(foo.bar.baz)
+      #
+      #   # good
+      #   defined?(foo.bar.baz)
+      class CombinableDefined < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Combine nested `defined?` calls.'
+        OPERATORS = %w[&& and].freeze
+
+        def on_and(node)
+          # Only register an offense if all `&&` terms are `defined?` calls
+          return unless (terms = terms(node)).all?(&:defined_type?)
+
+          calls = defined_calls(terms)
+          namespaces = namespaces(calls)
+
+          calls.each do |call|
+            next unless namespaces.any?(call)
+
+            add_offense(node) do |corrector|
+              remove_term(corrector, call)
+            end
+          end
+        end
+
+        private
+
+        def terms(node)
+          node.each_descendant.select do |descendant|
+            descendant.parent.and_type? && !descendant.and_type?
+          end
+        end
+
+        def defined_calls(nodes)
+          nodes.filter_map do |defined_node|
+            subject = defined_node.first_argument
+            subject if subject.type?(:const, :call)
+          end
+        end
+
+        def namespaces(nodes)
+          nodes.filter_map do |node|
+            if node.respond_to?(:namespace)
+              node.namespace
+            elsif node.respond_to?(:receiver)
+              node.receiver
+            end
+          end
+        end
+
+        def remove_term(corrector, term)
+          term = term.parent until term.parent.and_type?
+          range = if term == term.parent.children.last
+                    rhs_range_to_remove(term)
+                  else
+                    lhs_range_to_remove(term)
+                  end
+
+          corrector.remove(range)
+        end
+
+        # If the redundant `defined?` node is the LHS of an `and` node,
+        # the term as well as the subsequent `&&`/`and` operator will be removed.
+        def lhs_range_to_remove(term)
+          source = @processed_source.buffer.source
+
+          pos = term.source_range.end_pos
+          pos += 1 until source[..pos].end_with?(*OPERATORS)
+
+          range_with_surrounding_space(
+            range: term.source_range.with(end_pos: pos + 1),
+            side: :right,
+            newlines: false
+          )
+        end
+
+        # If the redundant `defined?` node is the RHS of an `and` node,
+        # the term as well as the preceding `&&`/`and` operator will be removed.
+        def rhs_range_to_remove(term)
+          source = @processed_source.buffer.source
+
+          pos = term.source_range.begin_pos
+          pos -= 1 until source[pos, 3].start_with?(*OPERATORS)
+
+          range_with_surrounding_space(
+            range: term.source_range.with(begin_pos: pos - 1),
+            side: :right,
+            newlines: false
+          )
+        end
+      end
+    end
+  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/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,6 +57,11 @@ module RuboCop
 
         REGEXP = /(?<keyword>\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|
             next unless offensive?(comment) && (match = source_line(comment).match(REGEXP))
@@ -83,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) }
@@ -93,7 +99,18 @@ module RuboCop
         end
 
         def rbs_inline_annotation?(line, comment)
-          comment.text.start_with?('#:') && line.start_with?(/\A\s*def\s/)
+          case line
+          when SUBCLASS_DEFINITION
+            comment.text.start_with?(/#\[.+\]/)
+          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

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

@@ -0,0 +1,75 @@
+# 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.
+      #
+      # @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