rubocop 1.71.1 → 1.88.2

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

@@ -3,10 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of Module#attr.
+      # Checks for uses of `Module#attr`. The `attr` method has confusing
+      # behavior: with a single argument it creates a reader (like `attr_reader`),
+      # but with a second boolean argument it creates an accessor (deprecated in
+      # Ruby 1.9). Use `attr_reader` or `attr_accessor` to make intent explicit.
       #
       # @example
-      #   # bad - creates a single attribute accessor (deprecated in Ruby 1.9)
+      #   # bad
       #   attr :something, true
       #   attr :one, :two, :three # behaves as attr_reader
       #

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks if usage of %() or %Q() matches configuration.
+      # Checks if usage of `%()` or `%Q()` matches configuration.
+      # Consistent use of one style makes the codebase easier
+      # to read.
       #
       # @example EnforcedStyle: bare_percent (default)
       #   # bad
@@ -41,8 +43,7 @@ module RuboCop
 
         def check(node)
           return if node.heredoc?
-          return unless node.loc.respond_to?(:begin)
-          return unless node.loc.begin
+          return unless node.loc?(:begin)
 
           source = node.loc.begin.source
           if requires_percent_q?(source)

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for BEGIN blocks.
+      # Checks for `BEGIN` blocks. They are Perl-style constructs that execute
+      # code before the rest of the file is parsed, making the control flow
+      # harder to follow and reason about.
       #
       # @example
       #   # bad

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

@@ -70,18 +70,25 @@ module RuboCop
             (send _ :& _))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           return unless node.receiver&.begin_type?
           return unless (preferred_method = preferred_method(node))
 
           bit_operation = node.receiver.children.first
           lhs, _operator, rhs = *bit_operation
-          preferred = "#{lhs.source}.#{preferred_method}(#{rhs.source})"
+
+          preferred = if preferred_method == 'allbits?' && lhs.source == node.first_argument.source
+                        "#{rhs.source}.allbits?(#{lhs.source})"
+                      else
+                        "#{lhs.source}.#{preferred_method}(#{rhs.source})"
+                      end
 
           add_offense(node, message: format(MSG, preferred: preferred)) do |corrector|
             corrector.replace(node, preferred)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 

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

@@ -4,7 +4,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for uses of braces or do/end around single line or
+      # Checks for uses of braces or do/end around single line or
       # multi-line blocks.
       #
       # Methods that can be either procedural or functional and cannot be
@@ -198,16 +198,18 @@ module RuboCop
         alias on_csend on_send
 
         def on_block(node)
-          return if ignored_node?(node)
+          return if part_of_ignored_node?(node)
           return if proper_block_style?(node)
 
           message = message(node)
           add_offense(node.loc.begin, message: message) do |corrector|
             autocorrect(corrector, node)
+            ignore_node(node)
           end
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -230,9 +232,7 @@ module RuboCop
         end
 
         def semantic_message(node)
-          block_begin = node.loc.begin.source
-
-          if block_begin == '{'
+          if node.braces?
             'Prefer `do...end` over `{...}` for procedural blocks.'
           else
             'Prefer `{...}` over `do...end` for functional blocks.'
@@ -347,7 +347,7 @@ module RuboCop
         # rubocop:disable Metrics/CyclomaticComplexity
         def get_blocks(node, &block)
           case node.type
-          when :block, :numblock
+          when :block, :numblock, :itblock
             yield node
           when :send, :csend
             # When a method has an argument which is another method with a block,
@@ -370,36 +370,42 @@ module RuboCop
         end
         # rubocop:enable Metrics/CyclomaticComplexity
 
+        # rubocop:disable Metrics/CyclomaticComplexity -- inlined special_method checks to avoid double evaluation
         def proper_block_style?(node)
           return true if require_do_end?(node)
-          return special_method_proper_block_style?(node) if special_method?(node.method_name)
+
+          method_name = node.method_name
+          return true if allowed_method?(method_name) || matches_allowed_pattern?(method_name)
+          return node.braces? if braces_required_method?(method_name)
 
           case style
           when :line_count_based    then line_count_based_block_style?(node)
           when :semantic            then semantic_block_style?(node)
           when :braces_for_chaining then braces_for_chaining_style?(node)
-          when :always_braces       then braces_style?(node)
+          when :always_braces       then node.braces?
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def require_do_end?(node)
           return false if node.braces? || node.multiline?
-          return false unless (resbody = node.each_descendant(:resbody).first)
 
-          resbody.children.first&.array_type?
-        end
+          body = node.body
+          return false unless body
+          # `ensure` and a block-level `rescue` are illegal inside `{ }`; only a
+          # bare modifier rescue (`expr rescue expr`) can be written with braces.
+          return true if body.ensure_type?
+          return false unless body.rescue_type?
 
-        def special_method?(method_name)
-          allowed_method?(method_name) ||
-            matches_allowed_pattern?(method_name) ||
-            braces_required_method?(method_name)
+          !modifier_rescue?(body)
         end
 
-        def special_method_proper_block_style?(node)
-          method_name = node.method_name
-          return true if allowed_method?(method_name) || matches_allowed_pattern?(method_name)
+        def modifier_rescue?(rescue_node)
+          return false if rescue_node.body.nil? || rescue_node.else_branch
+          return false unless rescue_node.resbody_branches.one?
 
-          node.braces? if braces_required_method?(method_name)
+          resbody = rescue_node.resbody_branches.first
+          resbody.exceptions.empty? && resbody.exception_variable.nil?
         end
 
         def braces_required_method?(method_name)
@@ -419,24 +425,18 @@ module RuboCop
 
           if node.braces?
             functional_method?(method_name) || functional_block?(node) ||
-              (procedural_oneliners_may_have_braces? && !node.multiline?)
+              (procedural_oneliners_may_have_braces? && node.single_line?)
           else
             procedural_method?(method_name) || !return_value_used?(node)
           end
         end
 
         def braces_for_chaining_style?(node)
-          block_begin = node.loc.begin.source
-
-          block_begin == if node.multiline?
-                           (node.chained? ? '{' : 'do')
-                         else
-                           '{'
-                         end
-        end
-
-        def braces_style?(node)
-          node.loc.begin.source == '{'
+          if node.multiline?
+            node.chained? ? node.braces? : !node.braces?
+          else
+            node.braces?
+          end
         end
 
         def correction_would_break_code?(node)
@@ -446,7 +446,11 @@ module RuboCop
         end
 
         def functional_method?(method_name)
-          cop_config['FunctionalMethods'].map(&:to_sym).include?(method_name)
+          functional_methods.include?(method_name)
+        end
+
+        def functional_methods
+          @functional_methods ||= cop_config['FunctionalMethods'].to_set(&:to_sym).freeze
         end
 
         def functional_block?(node)
@@ -458,7 +462,11 @@ module RuboCop
         end
 
         def procedural_method?(method_name)
-          cop_config['ProceduralMethods'].map(&:to_sym).include?(method_name)
+          procedural_methods.include?(method_name)
+        end
+
+        def procedural_methods
+          @procedural_methods ||= cop_config['ProceduralMethods'].to_set(&:to_sym).freeze
         end
 
         def return_value_used?(node)
@@ -487,7 +495,7 @@ module RuboCop
         def begin_required?(block_node)
           # If the block contains `rescue` or `ensure`, it needs to be wrapped in
           # `begin`...`end` when changing `do-end` to `{}`.
-          block_node.each_child_node(:rescue, :ensure).any? && !block_node.single_line?
+          block_node.each_child_node(:rescue, :ensure).any? && block_node.multiline?
         end
 
         def single_argument_operator_method?(node)

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

@@ -3,31 +3,40 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of the case equality operator(===).
+      # Checks for uses of the case equality operator (`===`).
+      # The `===` operator has different behavior depending on the
+      # receiver and its use outside of `case`/`when` is confusing.
+      # Prefer more explicit alternatives like `is_a?`, `include?`,
+      # or `match?`.
       #
       # If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of
       # the case equality operator is a constant.
-
+      #
       # If `AllowOnSelfClass` option is enabled, the cop will ignore violations when the receiver of
       # the case equality operator is `self.class`. Note intermediate variables are not accepted.
       #
+      # NOTE: Regexp case equality (`/regexp/ === var`) is allowed because changing it to
+      # `/regexp/.match?(var)` needs to take into account `Regexp.last_match?`, `$~`, `$1`, etc.
+      # This potentially incompatible transformation is handled by `Performance/RegexpMatch` cop.
+      #
       # @example
       #   # bad
       #   (1..100) === 7
-      #   /something/ === some_string
       #
       #   # good
-      #   something.is_a?(Array)
       #   (1..100).include?(7)
-      #   /something/.match?(some_string)
       #
       # @example AllowOnConstant: false (default)
       #   # bad
       #   Array === something
       #
+      #   # good
+      #   something.is_a?(Array)
+      #
       # @example AllowOnConstant: true
       #   # good
       #   Array === something
+      #   something.is_a?(Array)
       #
       # @example AllowOnSelfClass: false (default)
       #   # bad
@@ -51,7 +60,7 @@ module RuboCop
 
         def on_send(node)
           case_equality?(node) do |lhs, rhs|
-            return if lhs.const_type? && !lhs.module_name?
+            return if lhs.regexp_type? || (lhs.const_type? && !lhs.module_name?)
 
             add_offense(node.loc.selector) do |corrector|
               replacement = replacement(lhs, rhs)
@@ -71,13 +80,6 @@ module RuboCop
 
         def replacement(lhs, rhs)
           case lhs.type
-          when :regexp
-            # The automatic correction from `a === b` to `a.match?(b)` needs to
-            # consider `Regexp.last_match?`, `$~`, `$1`, and etc.
-            # This correction is expected to be supported by `Performance/Regexp` cop.
-            # See: https://github.com/rubocop/rubocop-performance/issues/152
-            #
-            # So here is noop.
           when :begin
             begin_replacement(lhs, rhs)
           when :const
@@ -94,13 +96,25 @@ module RuboCop
         end
 
         def const_replacement(lhs, rhs)
-          "#{rhs.source}.is_a?(#{lhs.source})"
+          "#{parenthesize_if_needed(rhs)}.is_a?(#{lhs.source})"
         end
 
         def send_replacement(lhs, rhs)
           return unless self_class?(lhs)
 
-          "#{rhs.source}.is_a?(#{lhs.source})"
+          "#{parenthesize_if_needed(rhs)}.is_a?(#{lhs.source})"
+        end
+
+        # `Array === a + b` must become `(a + b).is_a?(Array)`, not
+        # `a + b.is_a?(Array)` (which parses as `a + (b.is_a?(Array))`).
+        def parenthesize_if_needed(node)
+          requires_parentheses?(node) ? "(#{node.source})" : node.source
+        end
+
+        def requires_parentheses?(node)
+          return true if node.type?(:and, :or, :if, :range) || node.assignment?
+
+          node.send_type? && (node.operator_method? || node.unary_operation?)
         end
       end
     end

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

@@ -269,7 +269,7 @@ module RuboCop
         end
 
         def regexp_with_named_captures?(node)
-          node.regexp_type? && node.each_capture(named: true).count.positive?
+          node.regexp_type? && node.each_capture(named: true).any?
         end
       end
     end

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

@@ -8,8 +8,8 @@ module RuboCop
       # essentially one-character strings, so this syntax
       # is mostly redundant at this point.
       #
-      # ? character literal can be used to express meta and control character.
-      # That's a good use case of ? literal so it doesn't count it as an offense.
+      # A `?` character literal can be used to express meta and control characters.
+      # That's a good use case of a `?` literal so it doesn't count as an offense.
       #
       # @example
       #   # bad

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

@@ -3,29 +3,49 @@
 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.
       #
       # @example EnforcedStyle: nested (default)
+      #   # bad
+      #   class Foo::Bar
+      #   end
+      #
       #   # good
-      #   # have each child on its own line
       #   class Foo
       #     class Bar
       #     end
       #   end
       #
       # @example EnforcedStyle: compact
+      #   # bad
+      #   class Foo
+      #     class Bar
+      #     end
+      #   end
+      #
       #   # good
-      #   # combine definitions as much as possible
       #   class Foo::Bar
       #   end
       #
@@ -42,16 +62,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,21 +139,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 unless node.body.children.last
 
           last_child_leading_spaces = leading_spaces(node.body.children.last)
-          return if leading_spaces(node).size == last_child_leading_spaces.size
+          return if spaces_size(leading_spaces(node)) == spaces_size(last_child_leading_spaces)
 
-          column_delta = configured_indentation_width - last_child_leading_spaces.size
+          column_delta = configured_indentation_width - spaces_size(last_child_leading_spaces)
           return if column_delta.zero?
 
           AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
@@ -141,8 +169,19 @@ 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?
+          return unless const_namespace?(node.identifier.namespace)
 
           if style == :nested
             check_nested_style(node)
@@ -151,8 +190,16 @@ module RuboCop
           end
         end
 
+        def const_namespace?(node)
+          return true if node.nil? || node.cbase_type?
+          return false unless node.const_type?
+
+          const_namespace?(node.namespace)
+        end
+
         def check_nested_style(node)
           return unless compact_node_name?(node)
+          return if node.parent&.type?(:class, :module)
 
           add_offense(node.loc.name, message: NESTED_MSG) do |corrector|
             autocorrect(corrector, node)
@@ -183,6 +230,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))
@@ -90,25 +90,33 @@ module RuboCop
         private
 
         def class_name(class_node, node)
-          if class_name_method?(node.children.first.method_name)
-            if (receiver = class_node.receiver) && class_name_method?(class_node.method_name)
-              return receiver.source
-            end
+          unless class_name_method?(node.children.first.method_name)
+            # `var.class == 'Foo'` compares a `Class` to a `String` (always false) and
+            # has no valid `instance_of?` rewrite, so don't suggest one.
+            return if class_node.str_type?
 
-            if class_node.str_type?
-              value = trim_string_quotes(class_node)
-              value.prepend('::') if require_cbase?(class_node)
-              return value
-            elsif unable_to_determine_type?(class_node)
-              # When a variable or return value of a method is used, it returns nil
-              # because the type is not known and cannot be suggested.
-              return
-            end
+            return class_node.source
+          end
+
+          if (receiver = class_node.receiver) && class_name_method?(class_node.method_name)
+            return receiver.source
           end
 
+          return string_class_name(class_node) if class_node.str_type?
+          # When a variable or return value of a method is used, the type is not known
+          # and cannot be suggested.
+          return if unable_to_determine_type?(class_node)
+
           class_node.source
         end
 
+        def string_class_name(class_node)
+          value = trim_string_quotes(class_node)
+          # Avoid `::::Foo` when the name is already fully qualified.
+          value.prepend('::') if require_cbase?(class_node) && !value.start_with?('::')
+          value
+        end
+
         def class_name_method?(method_name)
           CLASS_NAME_METHODS.include?(method_name)
         end

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

@@ -140,15 +140,21 @@ module RuboCop
 
         def extract_def_from_sclass(def_node, sclass_node)
           range = source_range_with_comment(def_node)
-          source = range.source.sub!(
-            "def #{def_node.method_name}",
-            "def self.#{def_node.method_name}"
-          )
-
+          source = prefix_def_with_self(range, def_node)
           source = source.gsub(/^ {#{indentation_diff(def_node, sclass_node)}}/, '')
           [range, source.chomp]
         end
 
+        # Splice in `self.` at the actual `def` keyword rather than substituting the
+        # first textual `def <name>`, which may appear inside a preceding comment.
+        def prefix_def_with_self(range, def_node)
+          keyword_offset = def_node.loc.keyword.begin_pos - range.begin_pos
+          name_end_offset = def_node.loc.name.end_pos - range.begin_pos
+          source = range.source.dup
+          source[keyword_offset...name_end_offset] = "def self.#{def_node.method_name}"
+          source
+        end
+
         def indentation_diff(node1, node2)
           node1.loc.column - node2.loc.column
         end