rubocop 1.50.2 → 1.68.0

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -48,23 +48,27 @@ module RuboCop
         MSG = 'Use %<style>s block forwarding.'
 
         def self.autocorrect_incompatible_with
-          [Lint::AmbiguousOperator]
+          [Lint::AmbiguousOperator, Style::ArgumentsForwarding, Style::ExplicitBlockArgument]
         end
 
         def on_def(node)
           return if node.arguments.empty?
 
-          last_argument = node.arguments.last
+          last_argument = node.last_argument
           return if expected_block_forwarding_style?(node, last_argument)
 
-          register_offense(last_argument, node)
+          forwarded_args = node.each_descendant(:block_pass).with_object([]) do |block_pass, result|
+            return nil if invalidates_syntax?(block_pass)
+            next unless block_argument_name_matched?(block_pass, last_argument)
 
-          node.each_descendant(:block_pass) do |block_pass_node|
-            next if block_pass_node.children.first&.sym_type? ||
-                    last_argument.source != block_pass_node.source
+            result << block_pass
+          end
 
-            register_offense(block_pass_node, node)
+          forwarded_args.each do |forwarded_arg|
+            register_offense(forwarded_arg, node)
           end
+
+          register_offense(last_argument, node)
         end
         alias on_defs on_def
 
@@ -80,6 +84,29 @@ module RuboCop
           end
         end
 
+        def block_argument_name_matched?(block_pass_node, last_argument)
+          return false if block_pass_node.children.first&.sym_type?
+
+          last_argument.source == block_pass_node.source
+        end
+
+        # Prevents the following syntax error:
+        #
+        # # foo.rb
+        # def foo(&)
+        #   block_method do
+        #     bar(&)
+        #   end
+        # end
+        #
+        # $ ruby -vc foo.rb
+        # ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [x86_64-darwin22]
+        # foo.rb: foo.rb:4: anonymous block parameter is also used within block (SyntaxError)
+        #
+        def invalidates_syntax?(block_pass_node)
+          block_pass_node.each_ancestor(:block, :numblock).any?
+        end
+
         def use_kwarg_in_method_definition?(node)
           node.arguments.each_descendant(:kwarg, :kwoptarg).any?
         end
@@ -109,7 +136,7 @@ module RuboCop
         end
 
         def use_block_argument_as_local_variable?(node, last_argument)
-          return if node.body.nil?
+          return false if node.body.nil?
 
           node.body.each_descendant(:lvar, :lvasgn).any? do |lvar|
             !lvar.parent.block_pass_type? && lvar.node_parts[0].to_s == last_argument

data/lib/rubocop/cop/naming/constant_name.rb

@@ -61,8 +61,7 @@ module RuboCop
         end
 
         def allowed_method_call_on_rhs?(node)
-          node&.send_type? &&
-            (node.receiver.nil? || !literal_receiver?(node))
+          node&.send_type? && (node.receiver.nil? || !literal_receiver?(node))
         end
 
         # @!method literal_receiver?(node)
@@ -76,7 +75,7 @@ module RuboCop
         end
 
         def contains_constant?(node)
-          node.branches.any?(&:const_type?)
+          node.branches.compact.any?(&:const_type?)
         end
       end
     end

data/lib/rubocop/cop/naming/file_name.rb

@@ -57,7 +57,7 @@ module RuboCop
           file_path = processed_source.file_path
           return if config.file_to_exclude?(file_path) || config.allowed_camel_case_file?(file_path)
 
-          for_bad_filename(file_path) { |range, msg| add_offense(range, message: msg) }
+          for_bad_filename(file_path)
         end
 
         private
@@ -71,7 +71,7 @@ module RuboCop
             msg = other_message(basename) unless bad_filename_allowed?
           end
 
-          yield source_range(processed_source.buffer, 1, 0), msg if msg
+          add_global_offense(msg) if msg
         end
 
         def perform_class_and_module_naming_checks(file_path, basename)
@@ -136,7 +136,7 @@ module RuboCop
         end
 
         def filename_good?(basename)
-          basename = basename.sub(/^\./, '')
+          basename = basename.delete_prefix('.')
           basename = basename.sub(/\.[^.]+$/, '')
           # special handling for Action Pack Variants file names like
           # some_file.xlsx+mobile.axlsx

data/lib/rubocop/cop/naming/heredoc_delimiter_naming.rb

@@ -31,7 +31,9 @@ module RuboCop
         def on_heredoc(node)
           return if meaningful_delimiters?(node)
 
-          add_offense(node.loc.heredoc_end)
+          range = node.children.empty? ? node : node.loc.heredoc_end
+
+          add_offense(range)
         end
 
         private

data/lib/rubocop/cop/naming/inclusive_language.rb

@@ -116,9 +116,9 @@ module RuboCop
             add_offense(range, message: create_message(word)) do |corrector|
               suggestions = find_flagged_term(word)['Suggestions']
 
-              next unless suggestions.is_a?(String)
-
-              corrector.replace(range, suggestions)
+              if (preferred_term = preferred_sole_term(suggestions))
+                corrector.replace(range, preferred_term)
+              end
             end
           end
         end
@@ -157,6 +157,15 @@ module RuboCop
           set_regexes(flagged_term_strings, allowed_strings)
         end
 
+        def preferred_sole_term(suggestions)
+          case suggestions
+          when Array
+            suggestions.one? && preferred_sole_term(suggestions.first)
+          when String
+            suggestions
+          end
+        end
+
         def extract_regexp(term, term_definition)
           return term_definition['Regex'] if term_definition['Regex']
           return /(?:\b|(?<=[\W_]))#{term}(?:\b|(?=[\W_]))/ if term_definition['WholeWord']
@@ -207,8 +216,7 @@ module RuboCop
             message = create_multiple_word_message_for_file(words)
           end
 
-          range = source_range(processed_source.buffer, 1, 0)
-          add_offense(range, message: message)
+          add_global_offense(message)
         end
 
         def create_single_word_message_for_file(word)

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -17,7 +17,8 @@ module RuboCop
       # @safety
       #   This cop relies on the pattern `@instance_var ||= ...`,
       #   but this is sometimes used for other purposes than memoization
-      #   so this cop is considered unsafe.
+      #   so this cop is considered unsafe. Also, its autocorrection is unsafe
+      #   because it may conflict with instance variable names already in use.
       #
       # @example EnforcedStyleForLeadingUnderscores: disallowed (default)
       #   # bad
@@ -145,6 +146,8 @@ module RuboCop
       #     @_foo ||= calculate_expensive_thing
       #   end
       class MemoizedInstanceVariableName < Base
+        extend AutoCorrector
+
         include ConfigurableEnforcedStyle
 
         MSG = 'Memoized variable `%<var>s` does not match ' \
@@ -163,6 +166,7 @@ module RuboCop
         PATTERN
 
         # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
         def on_or_asgn(node)
           lhs, _value = *node
           return unless lhs.ivasgn_type?
@@ -175,14 +179,18 @@ module RuboCop
 
           return if matches?(method_name, lhs)
 
+          suggested_var = suggested_var(method_name)
           msg = format(
             message(lhs.children.first.to_s),
             var: lhs.children.first.to_s,
-            suggested_var: suggested_var(method_name),
+            suggested_var: suggested_var,
             method: method_name
           )
-          add_offense(lhs, message: msg)
+          add_offense(lhs, message: msg) do |corrector|
+            corrector.replace(lhs.loc.name, "@#{suggested_var}")
+          end
         end
+        # rubocop:enable Metrics/MethodLength
         # rubocop:enable Metrics/AbcSize
 
         # @!method defined_memoized?(node, ivar)
@@ -195,25 +203,32 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def on_defined?(node)
-          arg = node.arguments.first
-          return unless arg.ivar_type?
+          arg = node.first_argument
+          return false unless arg.ivar_type?
 
           method_node, method_name = find_definition(node)
-          return unless method_node
+          return false unless method_node
 
           var_name = arg.children.first
           defined_memoized?(method_node.body, var_name) do |defined_ivar, return_ivar, ivar_assign|
-            return if matches?(method_name, ivar_assign)
+            return false if matches?(method_name, ivar_assign)
 
+            suggested_var = suggested_var(method_name)
             msg = format(
               message(var_name.to_s),
               var: var_name.to_s,
-              suggested_var: suggested_var(method_name),
+              suggested_var: suggested_var,
               method: method_name
             )
-            add_offense(defined_ivar, message: msg)
-            add_offense(return_ivar, message: msg)
-            add_offense(ivar_assign.loc.name, message: msg)
+            add_offense(defined_ivar, message: msg) do |corrector|
+              corrector.replace(defined_ivar, "@#{suggested_var}")
+            end
+            add_offense(return_ivar, message: msg) do |corrector|
+              corrector.replace(return_ivar, "@#{suggested_var}")
+            end
+            add_offense(ivar_assign.loc.name, message: msg) do |corrector|
+              corrector.replace(ivar_assign.loc.name, "@#{suggested_var}")
+            end
           end
         end
         # rubocop:enable Metrics/AbcSize, Metrics/MethodLength

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -3,59 +3,75 @@
 module RuboCop
   module Cop
     module Naming
-      # Checks that predicate methods names end with a question mark and
+      # Checks that predicate method names end with a question mark and
       # do not start with a forbidden prefix.
       #
-      # A method is determined to be a predicate method if its name starts
-      # with one of the prefixes defined in the `NamePrefix` configuration.
-      # You can change what prefixes are considered by changing this option.
-      # Any method name that starts with one of these prefixes is required by
-      # the cop to end with a `?`. Other methods can be allowed by adding to
-      # the `AllowedMethods` configuration.
+      # A method is determined to be a predicate method if its name starts with
+      # one of the prefixes listed in the `NamePrefix` configuration. The list
+      # defaults to `is_`, `has_`, and `have_` but may be overridden.
       #
-      # NOTE: The `is_a?` method is allowed by default.
+      # Predicate methods must end with a question mark.
       #
-      # If `ForbiddenPrefixes` is set, methods that start with the configured
-      # prefixes will not be allowed and will be removed by autocorrection.
+      # When `ForbiddenPrefixes` is also set (as it is by default), predicate
+      # methods which begin with a forbidden prefix are not allowed, even if
+      # they end with a `?`. These methods should be changed to remove the
+      # prefix.
       #
-      # In other words, if `ForbiddenPrefixes` is empty, a method named `is_foo`
-      # will register an offense only due to the lack of question mark (and will be
-      # autocorrected to `is_foo?`). If `ForbiddenPrefixes` contains `is_`,
-      # `is_foo` will register an offense both because the ? is missing and because of
-      # the `is_` prefix, and will be corrected to `foo?`.
-      #
-      # NOTE: `ForbiddenPrefixes` is only applied to prefixes in `NamePrefix`;
-      # a prefix in the former but not the latter will not be considered by
-      # this cop.
-      #
-      # @example
+      # @example NamePrefix: ['is_', 'has_', 'have_'] (default)
       #   # bad
       #   def is_even(value)
       #   end
       #
-      #   def is_even?(value)
+      #   # When ForbiddenPrefixes: ['is_', 'has_', 'have_'] (default)
+      #   # good
+      #   def even?(value)
       #   end
       #
+      #   # When ForbiddenPrefixes: []
       #   # good
-      #   def even?(value)
+      #   def is_even?(value)
       #   end
       #
+      # @example NamePrefix: ['seems_to_be_']
       #   # bad
-      #   def has_value
+      #   def seems_to_be_even(value)
       #   end
       #
-      #   def has_value?
+      #   # When ForbiddenPrefixes: ['seems_to_be_']
+      #   # good
+      #   def even?(value)
       #   end
       #
+      #   # When ForbiddenPrefixes: []
       #   # good
-      #   def value?
+      #   def seems_to_be_even?(value)
       #   end
       #
       # @example AllowedMethods: ['is_a?'] (default)
+      #   # Despite starting with the `is_` prefix, this method is allowed
       #   # good
       #   def is_a?(value)
       #   end
       #
+      # @example AllowedMethods: ['is_even?']
+      #   # good
+      #   def is_even?(value)
+      #   end
+      #
+      # @example MethodDefinitionMacros: ['define_method', 'define_singleton_method'] (default)
+      #   # bad
+      #   define_method(:is_even) { |value| }
+      #
+      #   # good
+      #   define_method(:even?) { |value| }
+      #
+      # @example MethodDefinitionMacros: ['def_node_matcher']
+      #   # bad
+      #   def_node_matcher(:is_even) { |value| }
+      #
+      #   # good
+      #   def_node_matcher(:even?) { |value| }
+      #
       class PredicateName < Base
         include AllowedMethods
 
@@ -72,7 +88,7 @@ module RuboCop
               next if allowed_method_name?(method_name.to_s, prefix)
 
               add_offense(
-                node.first_argument.source_range,
+                node.first_argument,
                 message: message(method_name, expected_name(method_name.to_s, prefix))
               )
             end
@@ -93,13 +109,23 @@ module RuboCop
         end
         alias on_defs on_def
 
+        def validate_config
+          forbidden_prefixes.each do |forbidden_prefix|
+            next if predicate_prefixes.include?(forbidden_prefix)
+
+            raise ValidationError, <<~MSG.chomp
+              The `Naming/PredicateName` cop is misconfigured. Prefix #{forbidden_prefix} must be included in NamePrefix because it is included in ForbiddenPrefixes.
+            MSG
+          end
+        end
+
         private
 
         def allowed_method_name?(method_name, prefix)
           !(method_name.start_with?(prefix) && # cheap check to avoid allocating Regexp
               method_name.match?(/^#{prefix}[^0-9]/)) ||
             method_name == expected_name(method_name, prefix) ||
-            method_name.end_with?('=') || # rubocop:todo InternalAffairs/MethodNameEndWith
+            method_name.end_with?('=') ||
             allowed_method?(method_name)
         end
 
@@ -109,7 +135,7 @@ module RuboCop
                      else
                        method_name.dup
                      end
-          new_name << '?' unless method_name.end_with?('?') # rubocop:todo InternalAffairs/MethodNameEndWith
+          new_name << '?' unless method_name.end_with?('?')
           new_name
         end
 

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -82,9 +82,7 @@ module RuboCop
           message = message(node)
 
           add_offense(range, message: message) do |corrector|
-            corrector.replace(range, preferred_name)
-
-            correct_node(corrector, node.body, offending_name, preferred_name)
+            autocorrect(corrector, node, range, offending_name, preferred_name)
           end
         end
 
@@ -95,6 +93,16 @@ module RuboCop
           variable.source_range
         end
 
+        def autocorrect(corrector, node, range, offending_name, preferred_name)
+          corrector.replace(range, preferred_name)
+          correct_node(corrector, node.body, offending_name, preferred_name)
+          return unless (kwbegin_node = node.parent.each_ancestor(:kwbegin).first)
+
+          kwbegin_node.right_siblings.each do |child_node|
+            correct_node(corrector, child_node, offending_name, preferred_name)
+          end
+        end
+
         def variable_name_matches?(node, name)
           if node.masgn_type?
             node.each_descendant(:lvasgn).any? do |lvasgn_node|
@@ -105,13 +113,21 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def correct_node(corrector, node, offending_name, preferred_name)
           return unless node
 
           node.each_node(:lvar, :lvasgn, :masgn) do |child_node|
             next unless variable_name_matches?(child_node, offending_name)
 
-            corrector.replace(child_node, preferred_name) if child_node.lvar_type?
+            if child_node.lvar_type?
+              parent_node = child_node.parent
+              if parent_node.respond_to?(:value_omission?) && parent_node.value_omission?
+                corrector.insert_after(parent_node.loc.operator, " #{preferred_name}")
+              else
+                corrector.replace(child_node, preferred_name)
+              end
+            end
 
             if child_node.masgn_type? || child_node.lvasgn_type?
               correct_reassignment(corrector, child_node, offending_name, preferred_name)
@@ -119,6 +135,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         # If the exception variable is reassigned, that assignment needs to be corrected.
         # Further `lvar` nodes will not be corrected though since they now refer to a

data/lib/rubocop/cop/naming/variable_name.rb

@@ -20,9 +20,14 @@ module RuboCop
       #   # good
       #   fooBar = 1
       #
+      # @example AllowedIdentifiers: ['fooBar']
+      #   # good (with EnforcedStyle: snake_case)
+      #   fooBar = 1
+      #
       # @example AllowedPatterns: ['_v\d+\z']
-      #   # good
+      #   # good (with EnforcedStyle: camelCase)
       #   :release_v1
+      #
       class VariableName < Base
         include AllowedIdentifiers
         include ConfigurableNaming

data/lib/rubocop/cop/offense.rb

@@ -43,11 +43,10 @@ module RuboCop
       # @!attribute [r] cop_name
       #
       # @return [String]
-      #   a cop class name without department.
-      #   i.e. type of the violation.
+      #   the cop name as a String for which this offense is for.
       #
       # @example
-      #   'LineLength'
+      #   'Layout/LineLength'
       attr_reader :cop_name
 
       # @api private
@@ -97,8 +96,8 @@ module RuboCop
       # @!attribute [r] correctable?
       #
       # @return [Boolean]
-      #   whether this offense can be automatically corrected via
-      #   autocorrect or a todo.
+      #   whether this offense can be automatically corrected via autocorrect.
+      #   This includes todo comments, for example when requested with `--disable-uncorrectable`.
       def correctable?
         @status != :unsupported
       end

data/lib/rubocop/cop/registry.rb

@@ -300,7 +300,7 @@ module RuboCop
         unless given_badge.match?(real_badge)
           path = PathUtil.smart_path(source_path)
           warn "#{path}: #{given_badge} has the wrong namespace - " \
-               "should be #{real_badge.department}"
+               "replace it with #{given_badge.with_department(real_badge.department)}"
         end
 
         real_badge.to_s

data/lib/rubocop/cop/security/compound_hash.rb

@@ -30,8 +30,8 @@ module RuboCop
       class CompoundHash < Base
         COMBINATOR_IN_HASH_MSG = 'Use `[...].hash` instead of combining hash values manually.'
         MONUPLE_HASH_MSG =
-          'Delegate hash directly without wrapping in an array when only using a single value'
-        REDUNDANT_HASH_MSG = 'Calling .hash on elements of a hashed array is redundant'
+          'Delegate hash directly without wrapping in an array when only using a single value.'
+        REDUNDANT_HASH_MSG = 'Calling .hash on elements of a hashed array is redundant.'
 
         # @!method hash_method_definition?(node)
         def_node_matcher :hash_method_definition?, <<~PATTERN

data/lib/rubocop/cop/security/open.rb

@@ -23,6 +23,7 @@ module RuboCop
       #   # bad
       #   open(something)
       #   open("| #{something}")
+      #   open("| foo")
       #   URI.open(something)
       #
       #   # good
@@ -32,7 +33,6 @@ module RuboCop
       #
       #   # good (literal strings)
       #   open("foo.text")
-      #   open("| foo")
       #   URI.open("http://example.com")
       class Open < Base
         MSG = 'The use of `%<receiver>sopen` is a serious security risk.'
@@ -40,7 +40,7 @@ module RuboCop
 
         # @!method open?(node)
         def_node_matcher :open?, <<~PATTERN
-          (send ${nil? (const {nil? cbase} :URI)} :open $!str ...)
+          (send ${nil? (const {nil? cbase} :URI)} :open $_ ...)
         PATTERN
 
         def on_send(node)

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

@@ -8,6 +8,17 @@ module RuboCop
       # EnforcedStyle config covers only method definitions.
       # Applications of visibility methods to symbols can be controlled
       # using AllowModifiersOnSymbols config.
+      # Also, the visibility of `attr*` methods can be controlled using
+      # AllowModifiersOnAttrs config.
+      #
+      # In Ruby 3.0, `attr*` methods now return an array of defined method names
+      # as symbols. So we can write the modifier and `attr*` in inline style.
+      # AllowModifiersOnAttrs config allows `attr*` methods to be written in
+      # inline style without modifying applications that have been maintained
+      # for a long time in group style. Furthermore, developers who are not very
+      # familiar with Ruby may know that the modifier applies to `def`, but they
+      # may not know that it also applies to `attr*` methods. It would be easier
+      # to understand if we could write `attr*` methods in inline style.
       #
       # @safety
       #   Autocorrection is not safe, because the visibility of dynamically
@@ -57,6 +68,8 @@ module RuboCop
       #   class Foo
       #
       #     private :bar, :baz
+      #     private *%i[qux quux]
+      #     private *METHOD_NAMES
       #
       #   end
       #
@@ -65,6 +78,36 @@ module RuboCop
       #   class Foo
       #
       #     private :bar, :baz
+      #     private *%i[qux quux]
+      #     private *METHOD_NAMES
+      #
+      #   end
+      #
+      # @example AllowModifiersOnAttrs: true (default)
+      #   # good
+      #   class Foo
+      #
+      #     public attr_reader :bar
+      #     protected attr_writer :baz
+      #     private attr_accessor :qux
+      #     private attr :quux
+      #
+      #     def public_method; end
+      #
+      #     private
+      #
+      #     def private_method; end
+      #
+      #   end
+      #
+      # @example AllowModifiersOnAttrs: false
+      #   # bad
+      #   class Foo
+      #
+      #     public attr_reader :bar
+      #     protected attr_writer :baz
+      #     private attr_accessor :qux
+      #     private attr :quux
       #
       #   end
       class AccessModifierDeclarations < Base
@@ -89,13 +132,22 @@ module RuboCop
 
         # @!method access_modifier_with_symbol?(node)
         def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
-          (send nil? {:private :protected :public :module_function} (sym _))
+          (send nil? {:private :protected :public :module_function}
+            {(sym _) (splat {#percent_symbol_array? const})}
+          )
+        PATTERN
+
+        # @!method access_modifier_with_attr?(node)
+        def_node_matcher :access_modifier_with_attr?, <<~PATTERN
+          (send nil? {:private :protected :public :module_function}
+            (send nil? {:attr :attr_reader :attr_writer :attr_accessor} _))
         PATTERN
 
         def on_send(node)
           return unless node.access_modifier?
           return if ALLOWED_NODE_TYPES.include?(node.parent&.type)
           return if allow_modifiers_on_symbols?(node)
+          return if allow_modifiers_on_attrs?(node)
 
           if offense?(node)
             add_offense(node.loc.selector) do |corrector|
@@ -124,10 +176,18 @@ module RuboCop
           end
         end
 
+        def percent_symbol_array?(node)
+          node.array_type? && node.percent_literal?(:symbol)
+        end
+
         def allow_modifiers_on_symbols?(node)
           cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
         end
 
+        def allow_modifiers_on_attrs?(node)
+          cop_config['AllowModifiersOnAttrs'] && access_modifier_with_attr?(node)
+        end
+
         def offense?(node)
           (group_style? && access_modifier_is_inlined?(node) &&
             !right_siblings_same_inline_method?(node)) ||
@@ -168,12 +228,12 @@ module RuboCop
 
         def find_corresponding_def_node(node)
           if access_modifier_with_symbol?(node)
-            method_name = node.arguments.first.value
+            method_name = node.first_argument.respond_to?(:value) && node.first_argument.value
             node.parent.each_child_node(:def).find do |child|
               child.method?(method_name)
             end
           else
-            node.arguments.first
+            node.first_argument
           end
         end