rubocop 1.57.1 → 1.65.0

data/lib/rubocop/cop/mixin/alignment.rb

@@ -65,8 +65,12 @@ module RuboCop
         inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
       end
 
-      # @deprecated Use processed_source.comment_at_line(line)
+      # @deprecated Use processed_source.line_with_comment?(line)
       def end_of_line_comment(line)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `end_of_line_comment` is deprecated. Use `processed_source.line_with_comment?` instead.
+        WARNING
+
         processed_source.line_with_comment?(line)
       end
 

data/lib/rubocop/cop/mixin/allowed_methods.rb

@@ -15,7 +15,13 @@ module RuboCop
       end
 
       # @deprecated Use allowed_method? instead
-      alias ignored_method? allowed_method?
+      def ignored_method?
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `ignored_method?` is deprecated. Use `allowed_method?` instead.
+        WARNING
+
+        allowed_method?
+      end
 
       # @api public
       def allowed_methods

data/lib/rubocop/cop/mixin/allowed_pattern.rb

@@ -18,14 +18,26 @@ module RuboCop
       end
 
       # @deprecated Use allowed_line? instead
-      alias ignored_line? allowed_line?
+      def ignored_line?
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `ignored_line?` is deprecated. Use `allowed_line?` instead.
+        WARNING
+
+        allowed_line?
+      end
 
       def matches_allowed_pattern?(line)
         allowed_patterns.any? { |pattern| Regexp.new(pattern).match?(line) }
       end
 
-      # @deprecated Use matches_allowed_pattern?? instead
-      alias matches_ignored_pattern? matches_allowed_pattern?
+      # @deprecated Use matches_allowed_pattern? instead
+      def matches_ignored_pattern?
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `matches_ignored_pattern?` is deprecated. Use `matches_allowed_pattern?` instead.
+        WARNING
+
+        matches_allowed_pattern?
+      end
 
       def allowed_patterns
         # Since there could be a pattern specified in the default config, merge the two

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -218,7 +218,7 @@ module RuboCop
 
       # @api private
       def already_on_multiple_lines?(node)
-        return node.first_line != node.arguments.last.last_line if node.def_type?
+        return node.first_line != node.last_argument.last_line if node.def_type?
 
         !node.single_line?
       end

data/lib/rubocop/cop/mixin/code_length.rb

@@ -36,7 +36,7 @@ module RuboCop
         length = calculator.calculate
         return if length <= max_length
 
-        location = node.casgn_type? ? node.loc.name : node.source_range
+        location = location(node)
 
         add_offense(location, message: message(length, max_length)) { self.max = length }
       end
@@ -54,6 +54,17 @@ module RuboCop
           foldable_types: count_as_one
         )
       end
+
+      def location(node)
+        return node.loc.name if node.casgn_type?
+
+        if LSP.enabled?
+          end_range = node.loc.respond_to?(:name) ? node.loc.name : node.loc.begin
+          node.source_range.begin.join(end_range)
+        else
+          node.source_range
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -62,25 +62,29 @@ module RuboCop
       # Returns the end line of a node, which might be a comment and not part of the AST
       # End line is considered either the line at which another node starts, or
       # the line at which the parent node ends.
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Lint/DuplicateBranch
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def find_end_line(node)
-        if node.if_type? && node.else?
-          node.loc.else.line
-        elsif node.if_type? && node.ternary?
-          node.else_branch.loc.line
-        elsif node.if_type? && node.elsif?
-          node.each_ancestor(:if).find(&:if?).loc.end.line
+        if node.if_type?
+          if node.else?
+            node.loc.else.line
+          elsif node.ternary?
+            node.else_branch.loc.line
+          elsif node.elsif?
+            node.each_ancestor(:if).find(&:if?).loc.end.line
+          end
         elsif node.block_type? || node.numblock_type?
           node.loc.end.line
         elsif (next_sibling = node.right_sibling) && next_sibling.is_a?(AST::Node)
           next_sibling.loc.line
         elsif (parent = node.parent)
-          parent.loc.respond_to?(:end) && parent.loc.end ? parent.loc.end.line : parent.loc.line
-        else
-          node.loc.end.line
-        end
+          if parent.loc.respond_to?(:end) && parent.loc.end
+            parent.loc.end.line
+          else
+            parent.loc.line
+          end
+        end || node.loc.end.line
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Lint/DuplicateBranch
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     end
   end
 end

data/lib/rubocop/cop/mixin/configurable_formatting.rb

@@ -18,6 +18,7 @@ module RuboCop
         alternative_styles.each do |alternative|
           return unexpected_style_detected(alternative) if valid_name?(node, name, alternative)
         end
+        unrecognized_style_detected
       end
 
       def valid_name?(node, name, given_style = style)

data/lib/rubocop/cop/mixin/configurable_max.rb

@@ -4,11 +4,15 @@ module RuboCop
   module Cop
     # Handles `Max` configuration parameters, especially setting them to an
     # appropriate value with --auto-gen-config.
-    # @deprecated Use `exclude_limit ParameterName` instead.
+    # @deprecated Use `exclude_limit <ParameterName>` instead.
     module ConfigurableMax
       private
 
       def max=(value)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `max=` is deprecated. Use `exclude_limit <ParameterName>` instead.
+        WARNING
+
         cfg = config_to_allow_offenses
         cfg[:exclude_limit] ||= {}
         current_max = cfg[:exclude_limit][max_parameter_name]

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -48,29 +48,33 @@ module RuboCop
 
       def register_offense(node, message, replacement) # rubocop:disable Metrics/AbcSize
         add_offense(node.value, message: message) do |corrector|
-          if (def_node = def_node_that_require_parentheses(node))
-            last_argument = def_node.last_argument
-            if last_argument.nil? || !last_argument.hash_type?
-              next corrector.replace(node, replacement)
-            end
-
-            white_spaces = range_between(def_node.selector.end_pos,
-                                         def_node.first_argument.source_range.begin_pos)
-            corrector.replace(white_spaces, '(')
-            corrector.insert_after(last_argument, ')') if node == last_argument.pairs.last
-          end
           corrector.replace(node, replacement)
+
+          next unless (def_node = def_node_that_require_parentheses(node))
+
+          last_argument = def_node.last_argument
+          if last_argument.nil? || !last_argument.hash_type?
+            next corrector.replace(node, replacement)
+          end
+
+          white_spaces = range_between(def_node.selector.end_pos,
+                                       def_node.first_argument.source_range.begin_pos)
+          next if node.parent.braces?
+
+          corrector.replace(white_spaces, '(')
+          corrector.insert_after(last_argument, ')') if node == last_argument.pairs.last
         end
       end
 
       def ignore_mixed_hash_shorthand_syntax?(hash_node)
-        target_ruby_version <= 3.0 || enforced_shorthand_syntax != 'consistent' ||
+        target_ruby_version <= 3.0 ||
+          !%w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
           !hash_node.hash_type?
       end
 
       def ignore_hash_shorthand_syntax?(pair_node)
         target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either' ||
-          enforced_shorthand_syntax == 'consistent' ||
+          %w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
           !pair_node.parent.hash_type?
       end
 
@@ -169,6 +173,11 @@ module RuboCop
         hash_value_type_breakdown[:value_needed]&.any?
       end
 
+      def ignore_explicit_omissible_hash_shorthand_syntax?(hash_value_type_breakdown)
+        hash_value_type_breakdown.keys == [:value_omittable] &&
+          enforced_shorthand_syntax == 'either_consistent'
+      end
+
       def each_omitted_value_pair(hash_value_type_breakdown, &block)
         hash_value_type_breakdown[:value_omitted]&.each(&block)
       end
@@ -195,6 +204,7 @@ module RuboCop
 
       def no_mixed_shorthand_syntax_check(hash_value_type_breakdown)
         return if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
+        return if ignore_explicit_omissible_hash_shorthand_syntax?(hash_value_type_breakdown)
 
         each_omittable_value_pair(hash_value_type_breakdown) do |pair_node|
           hash_key_source = pair_node.key.source

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -49,13 +49,13 @@ module RuboCop
 
         return unless complexity > max
 
-        msg = format(self.class::MSG,
-                     method: method_name,
-                     complexity: complexity,
-                     abc_vector: abc_vector,
-                     max: max)
+        msg = format(
+          self.class::MSG,
+          method: method_name, complexity: complexity, abc_vector: abc_vector, max: max
+        )
+        location = location(node)
 
-        add_offense(node, message: msg) { self.max = complexity.ceil }
+        add_offense(location, message: msg) { self.max = complexity.ceil }
       end
 
       def complexity(body)
@@ -69,6 +69,15 @@ module RuboCop
         end
         score
       end
+
+      def location(node)
+        if LSP.enabled?
+          end_range = node.loc.respond_to?(:name) ? node.loc.name : node.loc.begin
+          node.source_range.begin.join(end_range)
+        else
+          node.source_range
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -189,7 +189,7 @@ module RuboCop
         case node.type
         when :casgn   then _scope, _lhs, rhs = *node
         when :op_asgn then _lhs, _op, rhs = *node
-        when :send    then rhs = node.last_argument
+        when :send, :csend then rhs = node.last_argument
         else               _lhs, rhs = *node
         end
         rhs

data/lib/rubocop/cop/mixin/preceding_following_alignment.rb

@@ -79,7 +79,7 @@ module RuboCop
       end
 
       def aligned_operator?(range, line)
-        (aligned_identical?(range, line) || aligned_assignment?(range, line))
+        aligned_identical?(range, line) || aligned_assignment?(range, line)
       end
 
       def aligned_words?(range, line)

data/lib/rubocop/cop/mixin/rescue_node.rb

@@ -18,6 +18,10 @@ module RuboCop
 
       # @deprecated Use ResbodyNode#exceptions instead
       def rescued_exceptions(resbody)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `rescued_exceptions` is deprecated. Use `ResbodyNode#exceptions` instead.
+        WARNING
+
         rescue_group, = *resbody
         if rescue_group
           rescue_group.values

data/lib/rubocop/cop/mixin/safe_assignment.rb

@@ -14,7 +14,7 @@ module RuboCop
       def_node_matcher :empty_condition?, '(begin)'
 
       # @!method setter_method?(node)
-      def_node_matcher :setter_method?, '[(send ...) setter_method?]'
+      def_node_matcher :setter_method?, '[(call ...) setter_method?]'
 
       # @!method safe_assignment?(node)
       def_node_matcher :safe_assignment?, '(begin {equals_asgn? #setter_method?})'

data/lib/rubocop/cop/mixin/space_before_punctuation.rb

@@ -36,7 +36,7 @@ module RuboCop
       end
 
       def space_required_after?(token)
-        token.left_curly_brace? && space_required_after_lcurly?
+        (token.left_curly_brace? || token.type == :tLAMBEG) && space_required_after_lcurly?
       end
 
       def space_required_after_lcurly?

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

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)

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)

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

@@ -207,8 +207,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

@@ -203,7 +203,7 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def on_defined?(node)
-          arg = node.arguments.first
+          arg = node.first_argument
           return false unless arg.ivar_type?
 
           method_node, method_name = find_definition(node)

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

@@ -99,7 +99,7 @@ module RuboCop
           !(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 +109,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/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
@@ -67,6 +78,34 @@ module RuboCop
       #     private :bar, :baz
       #
       #   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
         extend AutoCorrector
 
@@ -92,10 +131,17 @@ module RuboCop
           (send nil? {:private :protected :public :module_function} (sym _))
         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|
@@ -128,6 +174,10 @@ module RuboCop
           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 +218,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.value
             node.parent.each_child_node(:def).find do |child|
               child.method?(method_name)
             end
           else
-            node.arguments.first
+            node.first_argument
           end
         end
 

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

@@ -166,7 +166,7 @@ module RuboCop
               *processed_source.ast_with_comments[arg].map(&:text),
               "#{node.method_name} #{arg.source}"
             ]
-            if arg == node.arguments.first
+            if arg == node.first_argument
               lines
             else
               indent = ' ' * node.loc.column

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

@@ -41,6 +41,7 @@ module RuboCop
         def on_send(node)
           return unless node.command?(:alias_method)
           return unless style == :prefer_alias && alias_keyword_possible?(node)
+          return unless node.arguments.count == 2
 
           msg = format(MSG_ALIAS_METHOD, current: lexical_scope_type(node))
           add_offense(node.loc.selector, message: msg) do |corrector|